Java 8+
-
序章
一直听说 java 的各种锁、（线程）同步机制，一直没有深入探索。
最近多看了几篇博文，算是理解的比较深入一些了，特写本文做个记录。ben发布于博客园
锁是什么？
一种用于 多个线程运行时协调的机制。
作用如下：ben发布于博客园
1、用于多线程之间同步，比如，执行顺序先后。
2、确保共享数据安全——堆内存数据、方法区数据、类的变量（static）、实例的变量。
隐式锁 vs 显式锁
1、synchronized 是我了解到的 唯一的 隐式锁，由 JVM 自行实现。
2、其它的为 显式锁，比如，interface Lock、interface ReadWriteLock、class StampedLock 及其实现类。
class ReentrantLock 实现了 interface Lock。ben发布于博客园
synchronized
java 关键字。由JVM实现锁机制。
和 class Object 的 wait()/notify()/notifyAll() 配合使用。
特性：
可重入锁。非公平锁。独享锁。悲观锁。
插个翻译：Reentrant lock. Unfair locks. Exclusive locks. Pessimistic locks.。
随着 JVM 的发展，其锁机制也在逐步变化。ben发布于博客园
偏向锁、轻量级锁、重量级锁、锁膨胀 等概念都和它有关，这些概念 还涉及 synchronized 底层实现用到的 Java对象头——Monitor。
插个翻译：Biased locks, lightweight locks, heavyweight locks, lock expansion。
参考资料：The Java® Virtual Machine Specification: Java SE 8 Edition （pdf 文档可以去 Java官网下载）
The Java® Language Specification: Java SE 8 Edition
修饰 类方法（static），使用 Class 对象 关联的 monitor。
修饰 实例方法，使用 实例 this 对象 关联的 monitor。ben发布于博客园
当然，还可以锁定代码块。在 14.19 The synchronized Statement 中 有介绍：
interface Lock
方法定义：
实现类：
最出名的就是下面提到的 class ReentrantLock 。
class ReentrantLock
实现了 interface Lock。
底层使用 abstract class AbstractQueuedSynchronizer（#重点） 实现。
特性：
可重入锁。默认非公平锁，可以 初始化为 公平锁。独享锁。悲观锁。
类里面的 NonfairSync 为 非公平锁实现，而 FairSync 为公平锁。
单独使用（lock(), unlock()等），可以 保证 多线程时 共享数据安全。
结合 interface Condition 使用，可以 控制 多线程执行流程。
interface Condition
结构：
await() 类似于 Object 的 wait()，执行后，线程进入 阻塞状态。
signal()/signalAll() 类似于 Object 的 notify()/notify()All，唤醒阻塞的线程——一个或所有。
interface ReadWriteLock
适用于 读多写少 的场景。
提供了两个函数：
class ReentrantReadWriteLock
interface ReadWriteLock 的实现类。
底层使用 abstract class AbstractQueuedSynchronizer（#重点） 实现，内部类 Sync。
上面的内部类 ReadLock 和 WriteLock 都是实现了 Lock 接口的：
public static class ReadLock implements Lock, java.io.Serializable{
private final Sync sync;
}
public static class WriteLock implements Lock, java.io.Serializable {
private final Sync sync;
}类里面的 sync 属性是实现 锁机制的关键。
特性：
读锁 是 共享式，写锁 是 独享锁（排他锁）。可重入锁。
示例程序（通义千问）：
ReadWriteLockExample.java
// *** 来自 通义千问 ***
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.HashMap;
import java.util.Map;
public class ReadWriteLockExample {
private final Map<String, String> map = new HashMap<>();
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private final ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
private final ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
public String get(String key) {
readLock.lock();
try {
return map.get(key);
} finally {
readLock.unlock();
}
}
public void put(String key, String value) {
writeLock.lock();
try {
map.put(key, value);
} finally {
writeLock.unlock();
}
}
public void remove(String key) {
writeLock.lock();
try {
map.remove(key);
} finally {
writeLock.unlock();
}
}
public static void main(String[] args) {
ReadWriteLockExample example = new ReadWriteLockExample();
// 创建多个读线程
for (int i = 0; i < 5; i++) {
final int threadId = i;
new Thread(() -> {
for (int j = 0; j < 10; j++) {
String value = example.get("key" + (j % 5));
System.out.println("Reader " + threadId + ": key" + (j % 5) + " = " + value);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "Reader-" + i).start();
}
// 创建一个写线程
new Thread(() -> {
for (int i = 0; i < 10; i++) {
example.put("key" + i, "value" + i);
System.out.println("Writer: Put key" + i + " = value" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "Writer").start();
}
}程序说明：
class StampedLock
Since: 1.8，Java 8 才开始有的。
参考资料#2 提供了足够多的信息。
适用于 读操作远远大于写操作 的场景——更胜于 前面的 interface ReadWriteLock。
特性：
乐观读锁。
类：
Node 类：
示例程序（通义千问）：
StampedLockExample.java
// 来自 通义千问
import java.util.concurrent.locks.StampedLock;
import java.util.HashMap;
import java.util.Map;
public class StampedLockExample {
private final Map<String, String> map = new HashMap<>();
private final StampedLock lock = new StampedLock();
public String getOptimistic(String key) {
long stamp = lock.tryOptimisticRead();
String value = map.get(key);
// 检查是否有写操作发生
if (!lock.validate(stamp)) {
// 升级为悲观读锁
stamp = lock.readLock();
try {
value = map.get(key);
} finally {
lock.unlockRead(stamp);
}
}
return value;
}
public String get(String key) {
long stamp = lock.readLock();
try {
return map.get(key);
} finally {
lock.unlockRead(stamp);
}
}
public void put(String key, String value) {
long stamp = lock.writeLock();
try {
map.put(key, value);
} finally {
lock.unlockWrite(stamp);
}
}
public void remove(String key) {
long stamp = lock.writeLock();
try {
map.remove(key);
} finally {
lock.unlockWrite(stamp);
}
}
public static void main(String[] args) {
StampedLockExample example = new StampedLockExample();
// 创建多个读线程
for (int i = 0; i < 5; i++) {
final int threadId = i;
new Thread(() -> {
for (int j = 0; j < 10; j++) {
String value = example.getOptimistic("key" + (j % 5));
System.out.println("Reader " + threadId + ": key" + (j % 5) + " = " + value);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "Reader-" + i).start();
}
// 创建一个写线程
new Thread(() -> {
for (int i = 0; i < 10; i++) {
example.put("key" + i, "value" + i);
System.out.println("Writer: Put key" + i + " = value" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "Writer").start();
}
}说明：
小结
探索 期间，遇到了 AbstractQueuedSynchronizer、Unsafe 等，还需要进一步探索（看更多博文呗）。
整个 java.util.concurrent.locks 包 下的内容：
疑问：
有了这些锁机制，为什么还需要 class CountDownLatch、class CyclicBarrier、class Semaphore 等呢？它们和 多线程开发 有什么关系？
还有就是 java.util.concurrent.atomic 下的东西。
---END---
本文链接：
https://www.cnblogs.com/luo630/p/18445669/java-locks-note
参考资料
1、java里的锁总结（synchronized隐式锁、Lock显式锁、volatile、CAS）
https://www.cnblogs.com/lifegoeson/p/13683785.html
posted @ 2020-09-17 10:38 Life_Goes_On
2、深入了解Java中的锁机制
2024-03-04
https://developer.aliyun.com/article/1449639
3、一文彻底搞懂面试中常问的各种“锁”
https://www.cnblogs.com/coding-night/p/10657892.html
posted on 2019-04-05 08:24 深夜里的程序猿
4、
ben发布于博客园
ben发布于博客园
标签：各种,java,String,探索,lock,value,key,class From： https://www.cnblogs.com/luo630/p/18445669/java-locks-note