重入锁 ReentrantLock 和读写锁 ReentrantReadWriteLock 是两个使用很广泛的同步组件，本文将详细介绍这两种锁特性、用法以及个别方法的源码分析
文章目录
重入锁——ReentrantLock
1. ReentrantLock的特性
-
支持对资源的重复加锁：已经获取锁的线程，再次调用lock()方法时，能够再次获取到锁而不被阻塞
-
支持获取锁时公平性和非公平性的选择：默认是非公平性的锁
synchronized关键字支持隐式的重进入，执行线程在获取了锁之后仍能连续多次的获取同一把锁而不被阻塞。ReentrantLock虽然不能隐式的重进入，但是支持显示的多次获取同一把锁。
2. 重进入的实现
实现重进入需要解决以下两个问题：
-
线程再次获取锁： 锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是则再次获取锁成功
-
锁的最终释放： 线程重复n次获取了锁，对应的需要n次解锁，第n次解锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增，释放时则计数自减，当等于0时表示锁已经成功释放
ReentrantLock 把聚合同步器的操作委托给了内部类 Sync，在构造器中会返回一个 Sync 对象，默认的是以非公平的方式获取锁，其源码如下：
// ReentrantLock 的无参构造器
public ReentrantLock() {
// 返回一个非公平的Sync
sync = new NonfairSync();
}
// 非公平获取锁的源码
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
// 得到当前线程的同步状态
int c = getState();
// 如果为0，加锁
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 如果已经是加了锁的线程，增加同步状态值
else if (current == getExclusiveOwnerThread()) {
// 增加同步状态值，获取一次加一次
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
// 设置同步状态值
setState(nextc);
return true;
}
return false;
}
ReentrantLock 加了几次锁，相对应的就要释放几次锁，下面是 ReentrantLock 释放锁的方法 tryRelease(int release) 的源码：
protected final boolean tryRelease(int releases) {
// 没释放一次同步状态减1，直到为0
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 当同步状态为0，表示该线程已经释放完了锁
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
// 设置同步状态
setState(c);
return free;
}
3. 公平锁与非公平锁
-
公平锁： 在一组线程里，保证每个线程都能拿到锁，即线程按照发出的请求顺序获取锁，不可抢占
-
非公平锁： 在一组线程里，并不一定每个线程都能拿到锁，即允许线程插队获取锁，可抢占
下面是演示公平锁和非公平锁的例子：
public class TestFailUnfail {
private ReentrantLock lock;
public TestFailUnfail(boolean isFail) {
lock = new ReentrantLock(isFail);
}
public void service() {
lock.lock();
try {
System.out.println("ThreadName：" + Thread.currentThread().getName() + "获得了锁！");
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
// true : 公平锁
// false : 非公平锁
final TestFailUnfail test = new TestFailUnfail(true);
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("线程 " + Thread.currentThread().getName() + " 运行！");
test.service();
}
};
Thread[] threads = new Thread[5];
for (int i = 0; i < 5; i++) {
threads[i] = new Thread(runnable);
}
for (int i = 0; i < 5; i++) {
threads[i].start();
}
}
}
// 公平锁：线程的启动顺序和加锁的顺序一致，说明先请求的线程先获得锁
线程 Thread-0 运行！
ThreadName：Thread-0获得了锁！
线程 Thread-1 运行！
ThreadName：Thread-1获得了锁！
线程 Thread-2 运行！
ThreadName：Thread-2获得了锁！
线程 Thread-3 运行！
ThreadName：Thread-3获得了锁！
线程 Thread-4 运行！
ThreadName：Thread-4获得了锁！
// 非公平锁：线程的启动顺序和加锁的顺序不一致，说明线程对锁发生了争抢，并且抢夺成功
线程 Thread-0 运行！
线程 Thread-2 运行！
线程 Thread-1 运行！
ThreadName：Thread-2获得了锁！
线程 Thread-3 运行！
ThreadName：Thread-1获得了锁！
线程 Thread-4 运行！
ThreadName：Thread-4获得了锁！
ThreadName：Thread-0获得了锁！
ThreadName：Thread-3获得了锁！
上面的例子介绍了公平锁和非公平锁的区别，现在说说它是怎么实现的：其实要想先请求先获取，其原理不就是FIFO(先进先出)嘛，只要保证先入队列的线程先获得锁，后入队的线程等待就行，下面是公平获取锁 tryAcquire(int acquires) 的源码：
// 与 nonfairTryAcquire(int acquires) 相比，加了判断条件方法 hasQueuedPredecessors()
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 判断一下该线程有没有头结点
// 如果有：说明前面有线程在获取锁，等待
// 如果没有：获取锁
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
公平锁和非公平锁的使用：
-
公平锁保证了锁的获取按照FIFO原则，但是却付出了大量线程切换的代价，将一个被挂起的线程恢复执行需要消耗大量时间。其适合于业务线程占用时间较长的场景，可以增加可控性。
-
非公平锁可能造成线程饥饿，即有一部分线程可能永远也无法获取到锁。但是其优势却很显著：只需要极少的线程切换，保证了更大的吞吐量。其适合于吞吐量要求比较高的场景(默认选择就是了)
4. 如何选择 synchronized 和 ReentrantLock
ReentrantLock 在加锁的内存语义上与内置锁相同，此外还提供了一些其他的功能：定时的锁等待、可中断的锁等待、公平性以及非块结构的加锁等。既然ReentrantLock有如此多优越的特性，那我们是不是就要放弃使用 synchronized 呢？显然不是这样，自从JDK1.6对 synchronized 做了优化之后(偏向锁、轻量级锁等)，内置锁已经不再那么的重量了。同时，内置锁有着很多优越的条件：隐式的重进入、简洁紧凑、易于使用和理解等等。
所以关于两种锁的选择策略是：在一些内置锁无法满足需求的情况下，ReentrantLock 可以作为一种高级工具。当需要一些高级功能时才应该使用 ReentrantLock，如：可定时的、可轮询的与可中断的锁获取操作，公平队列以及非块结构的锁。否则，应该优先使用 synchronized。
读写锁——ReentrantReadWriteLock
前面所说的锁都是独占锁(排他锁)，即同一时刻只能有一个线程获取同一把锁。而读写锁是共享锁，即同一时刻可以允许多个读线程访问，在写线程访问时，其他所有的读线程和写线程阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的排他锁有了很大的性能提升。
在Java并发包中提供了ReentrantReadWriteLock来实现读写锁，其特性如下：
| 特性 | 描述 |
|---|---|
| 公平性选择 | 支持非公平(默认)和公平的锁获取方式，吞吐量非公平优于公平 |
| 重进入 | 支持重进入，读线程获取了读锁之后能再次获取读锁；写线程获取了写锁之后能再次获取写锁，同时也可以获取读锁 |
| 锁降级 | 遵循：获取写锁——获取读锁-释放写锁 的次序，写锁能够降级为读锁 |
1. 读锁示例
下面的例子演示了使用读写锁实现缓存，缓存值存放于非线程安全的 HashMap 中，使用读锁来保证 get() 的安全性，使用写锁来保证 put() 的安全性。在执行 get() 操作时，所有的读线程都可以获得锁，但是所有的写线程均需阻塞等待；在执行 put() 操作时，只有一个写线程可以获得锁，其他的读线程和写线程均需阻塞等待，只有写锁被释放后，其他线程才可以获取锁。
public class TestReadWriteLock {
private static Map<Integer, Object> map = new HashMap<>();
private static ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
// 读锁
private static Lock readLock = rw.readLock();
// 写锁
private static Lock writeLock = rw.writeLock();
// 获取一个key对应的value
public static final Object get(Integer key) {
readLock.lock();
try {
return map.get(key);
} finally {
readLock.unlock();
}
}
// 设置key对应的value，并返回原value
public static final Object put(Integer key, Object value) {
writeLock.lock();
try {
return map.put(key, value);
} finally {
writeLock.unlock();
}
}
// 清空
public static final void clear() {
writeLock.lock();
try {
map.clear();
} finally {
writeLock.unlock();
}
}
public static void main(String[] args) {
final TestReadWriteLock test = new TestReadWriteLock();
String[] str1 = new String[5];
String[] str2 = new String[5];
Runnable runnable1 = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
test.put(i, "大米" + i);
}
}
};
Runnable runnable2 = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
str1[i] = (String) test.put(i, "蔬菜" + i);
}
}
};
Runnable runnable3 = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
str2[i] = (String) test.get(i);
}
}
};
Thread[] threadA = new Thread[5];
Thread[] threadB = new Thread[5];
Thread[] threadC = new Thread[5];
for (int i = 0; i < 5; i++) {
threadA[i] = new Thread(runnable1);
threadB[i] = new Thread(runnable2);
threadC[i] = new Thread(runnable3);
}
for (int i = 0; i < 5; i++) {
threadA[i].start();
threadB[i].start();
threadC[i].start();
}
for (int i = 0; i < 5; i++) {
System.out.println(str1[i]);
}
System.out.println("=========================");
for (int i = 0; i < 5; i++) {
System.out.println(str2[i]);
}
}
}
// 结果如下：
大米0
大米1
大米2
大米3
大米4
=========================
蔬菜0
蔬菜1
蔬菜2
蔬菜3
蔬菜4
2. 读写锁的实现
1. 读写状态的设计
读写锁也依赖于同步器来实现同步功能，读写状态就是同步器的同步器状态，同步状态表示锁被一个线程功夫获取的次数。读写锁的同步状态的维护要比独占锁复杂一些，因为读锁可以被多个线程获取，那么自然会有多个读状态需要维护。
如果在一个整型变量上维护多种状态，需要按位切割使用这个变量，读写锁将变量切分成两个部分：高16位表示读，低16位表示写
上图中读状态为2，说明获取了两次读锁；写状态为3，表示获取了3次写锁。读写锁通过位运算来确定各自的状态，假设当前同步状态值为S：
-
写状态等于 S & 0x0000FFFF，将高16位全部抹去。写状态增加1，等于 S+1
-
读状态等于 S >>>，无符号右移16位，前面补0。读状态增加1，等于 S+(1 << 16)，即 S+0x00010000
结论： S不等于0时，当写状态等于0，则读状态大于0，即读锁被获取
补充Java中的移位操作符：>>, <<, >>> 针对的是二进制位
-
>>： 带符号右移操作符，即按照指定位数整体右移，右移几位就在最左侧补上几位(注意：正数补0，负数补1)
-
<<： 左移操作符，即按照指定位数整体左移，左移几位就在最右侧补上几个0
-
>>>： Java独有的无符号右移操作符，无论正负，都在高位补上0
2. 写锁的获取与释放
写锁是一个支持重进入的独占锁，其获取同步状态方法 tryAcquire(int acquires) 的源码如下：
protected final boolean tryAcquire(int acquires) {
Thread current = Thread.currentThread();
int c = getState();
int w = exclusiveCount(c);
// 同步状态不为0
if (c != 0) {
// (Note: if c != 0 and w == 0 then shared count != 0)
// 写状态为0，没有线程获取到写锁
// 但是同步状态不为0，说明读线程正在持有锁，写线程阻塞等待
if (w == 0 || current != getExclusiveOwnerThread())
return false;
if (w + exclusiveCount(acquires) > MAX_COUNT)
throw new Error("Maximum lock count exceeded");
// Reentrant acquire
// 设置同步状态
setState(c + acquires);
return true;
}
if (writerShouldBlock() ||
!compareAndSetState(c, c + acquires))
return false;
setExclusiveOwnerThread(current);
return true;
}
3. 读锁的获取与释放
读锁是一个支持重进入的共享锁，它能被多个线程同时获取，其获取同步状态的方法 tryAcquireShared(int unused) 的源码如下：
protected final int tryAcquireShared(int unused) {
Thread current = Thread.currentThread();
int c = getState();
// 如果写锁被另一线程占有，而不是当前线程占有，则获取失败
if (exclusiveCount(c) != 0 &&
getExclusiveOwnerThread() != current)
return -1;
int r = sharedCount(c);
if (!readerShouldBlock() &&
r < MAX_COUNT &&
compareAndSetState(c, c + SHARED_UNIT)) {
if (r == 0) {
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
// 重进入
} else {
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
cachedHoldCounter = rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
}
return 1;
}
return fullTryAcquireShared(current);
}
4. 锁降级
指写锁降级为读锁：把持住当前拥有的写锁，再次获取到读锁，随后释放写锁的过程(当前线程先拥有写锁，随后释放，再获取读锁，这种分段获取锁的过程不是锁降级)。锁降级示例如下：
public void process() {
readLock.lock();
if(!update) {
// 先释放读锁
readLock.unlock();
// 锁降级从获取到写锁开始
writeLock.lock();
try {
if(!update) {
// 准备数据流程
update = true;
}
// 获取读锁，还没有释放写锁
readLock.lock();
} finally {
// 释放写锁
writeLock.unlock();
}
// 锁降级完成
}
try {
// 使用数据流程
} finally {
readLock.unlock();
}
}
锁降级的作用： 保证数据的可见性。如果当前线程不获取读锁而直接释放写锁，假设此刻另一个线程T获取了写锁并修改了数据，当前线程则无法感知到T的数据更新。如果当前线程获取了读锁，遵循锁降级的步骤，线程T会被阻塞，直到当前线程使用数据并释放读锁之后，线程T才能获取写锁进行数据更新。ReentrantReadWriteLock不支持锁升级(把持读锁、获取写锁、释放读锁)，也是为了保证数据可见性，如果读锁已经被多个线程获取，其中任意线程获取了写锁并更新了数据，其更新操作对于其他线程是不可见的。
参考
《Java并发编程的艺术》
《Java并发编程实战》
1426
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
