同步中的四种锁synchronizedReentrantLockReadWriteLockStampedLock

Posted 2020-09-20 只会一点java

为了更好的支持并发程序，JDK内部提供了多种锁。本文总结4种锁。

1.synchronized同步锁

使用：

synchronized本质上就2种锁：

1.锁同步代码块

2.锁方法

可用object.wait() object.notify()来操作线程等待唤醒

原理：synchronized细节的描述传送门：jdk源码剖析三：锁Synchronized

性能和建议：JDK6之后，在并发量不是特别大的情况下，性能中等且稳定。建议新手使用。

2.ReentrantLock可重入锁（Lock接口）

使用：ReentrantLock是Lock接口的实现类。Lock接口的核心方法是lock()，unlock()，tryLock()。可用Condition来操作线程：

如上图，await()和object.wait()类似，singal()和object.notify()类似，singalAll()和object.notifyAll()类似

原理：核心类AbstractQueuedSynchronizer，通过构造一个基于阻塞的CLH队列容纳所有的阻塞线程，而对该队列的操作均通过Lock-Free（CAS）操作，但对已经获得锁的线程而言，ReentrantLock实现了偏向锁的功能。

性能和建议：性能中等，建议需要手动操作线程时使用。

 

3.ReentrantReadWriteLock可重入读写锁（ReadWriteLock接口）

使用：ReentrantReadWriteLock是ReadWriteLock接口的实现类。ReadWriteLock接口的核心方法是readLock()，writeLock()。实现了并发读、互斥写。但读锁会阻塞写锁，是悲观锁的策略。

原理：类图如下：

JDK1.8下，如图ReentrantReadWriteLock有5个静态方法：

• Sync：继承于经典的AbstractQueuedSynchronizer（传说中的AQS）,是一个抽象类，包含2个抽象方法readerShouldBlock()；writerShouldBlock()
• FairSync和NonfairSync：继承于Sync,分别实现了公平/非公平锁。
• ReadLock和WriteLock：都是Lock实现类，分别实现了读、写锁。ReadLock是共享的，而WriteLock是独占的。于是Sync类覆盖了AQS中独占和共享模式的抽象方法(tryAcquire/tryAcquireShared等)，用同一个等待队列来维护读/写排队线程，而用一个32位int state标示和记录读/写锁重入次数--Doug Lea把状态的高16位用作读锁，记录所有读锁重入次数之和，低16位用作写锁，记录写锁重入次数。所以无论是读锁还是写锁最多只能被持有65535次。

性能和建议：适用于读多写少的情况。性能较高。

• 公平性

1. 非公平锁（默认）,为了防止写线程饿死，规则是：当等待队列头部结点是独占模式（即要获取写锁的线程）时，只有获取独占锁线程可以抢占，而试图获取共享锁的线程必须进入队列阻塞；当队列头部结点是共享模式（即要获取读锁的线程）时，试图获取独占和共享锁的线程都可以抢占。
2. 公平锁，利用AQS的等待队列，线程按照FIFO的顺序获取锁，因此不存在写线程一直等待的问题。

• 重入性：读写锁均是可重入的，读/写锁重入次数保存在了32位int state的高/低16位中。而单个读线程的重入次数，则记录在ThreadLocalHoldCounter类型的readHolds里。
• 锁降级：写线程获取写入锁后可以获取读取锁，然后释放写入锁，这样就从写入锁变成了读取锁，从而实现锁降级。
• 锁获取中断：读取锁和写入锁都支持获取锁期间被中断。
• 条件变量：写锁提供了条件变量(Condition)的支持，这个和独占锁ReentrantLock一致，但是读锁却不允许，调用readLock().newCondition()会抛出UnsupportedOperationException异常。

应用：

4.StampedLock戳锁

使用：

StampedLock控制锁有三种模式（排它写，悲观读，乐观读），一个StampedLock状态是由版本和模式两个部分组成，锁获取方法返回一个数字作为票据stamp，它用相应的锁状态表示并控制访问。下面是JDK1.8源码自带的示例：

 1 public class StampedLockDemo {
 2     //一个点的x，y坐标
 3     private double x,y;
 4     private final StampedLock sl = new StampedLock();
 5 
 6     //【写锁(排它锁)】
 7     void move(double deltaX,double deltaY) {// an exclusively locked method 
 8         /**stampedLock调用writeLock和unlockWrite时候都会导致stampedLock的stamp值的变化
 9          * 即每次+1，直到加到最大值，然后从0重新开始 
10          **/
11         long stamp =sl.writeLock(); //写锁
12         try {
13             x +=deltaX;
14             y +=deltaY;
15         } finally {
16             sl.unlockWrite(stamp);//释放写锁
17         }
18     }
19 
20     //【乐观读锁】
21     double distanceFromOrigin() { // A read-only method
22         /**
23          * tryOptimisticRead是一个乐观的读，使用这种锁的读不阻塞写
24          * 每次读的时候得到一个当前的stamp值（类似时间戳的作用）
25          */
26         long stamp = sl.tryOptimisticRead();
27         //这里就是读操作，读取x和y，因为读取x时，y可能被写了新的值，所以下面需要判断
28         double currentX = x, currentY = y;
29         /**如果读取的时候发生了写，则stampedLock的stamp属性值会变化，此时需要重读，
30          * 再重读的时候需要加读锁（并且重读时使用的应当是悲观的读锁，即阻塞写的读锁）
31          * 当然重读的时候还可以使用tryOptimisticRead，此时需要结合循环了，即类似CAS方式
32          * 读锁又重新返回一个stampe值*/
33         if (!sl.validate(stamp)) {//如果验证失败（读之前已发生写）
34             stamp = sl.readLock(); //悲观读锁
35             try {
36                 currentX = x;
37                 currentY = y;
38             }finally{
39                 sl.unlockRead(stamp);//释放读锁
40             }
41         }
42         //读锁验证成功后执行计算，即读的时候没有发生写
43         return Math.sqrt(currentX *currentX + currentY *currentY);
44     }
45 
46     //【悲观读锁】
47     void moveIfAtOrigin(double newX, double newY) { // upgrade
48         // 读锁（这里可用乐观锁替代）
49         long stamp = sl.readLock();
50         try {
51             //循环，检查当前状态是否符合
52             while (x == 0.0 && y == 0.0) {
53             /**
54              * 转换当前读戳为写戳，即上写锁
55              * 1.写锁戳，直接返回写锁戳
56              * 2.读锁戳且写锁可获得，则释放读锁，返回写锁戳
57              * 3.乐观读戳，当立即可用时返回写锁戳
58              * 4.其他情况返回0
59              */
60             long ws = sl.tryConvertToWriteLock(stamp);
61             //如果写锁成功
62             if (ws != 0L) {
63               stamp = ws;// 替换票据为写锁
64               x = newX;//修改数据
65               y = newY;
66               break;
67             }
68             //转换为写锁失败
69             else {
70                 //释放读锁
71                 sl.unlockRead(stamp);
72                 //获取写锁（必要情况下阻塞一直到获取写锁成功）
73                 stamp = sl.writeLock();
74             }
75           }
76         } finally {
77             //释放锁（可能是读/写锁）
78             sl.unlock(stamp);
79         }
80     }
81 }

 

原理：

StampedLockd的内部实现是基于CLH锁的，一种自旋锁，保证没有饥饿且FIFO。

CLH锁原理：锁维护着一个等待线程队列，所有申请锁且失败的线程都记录在队列。一个节点代表一个线程，保存着一个标记位locked,用以判断当前线程是否已经释放锁。当一个线程试图获取锁时，从队列尾节点作为前序节点，循环判断所有的前序节点是否已经成功释放锁。

如上图所示，StampedLockd源码中的WNote就是等待链表队列，每一个WNode标识一个等待线程，whead为CLH队列头，wtail为CLH队列尾，state为锁的状态。long型即64位，倒数第八位标识写锁状态，如果为1，标识写锁占用！下面围绕这个state来讲述锁操作。

首先是常量标识：

WBIT=1000 0000（即-128）

RBIT =0111 1111（即127） 

SBIT =1000 0000（后7位表示当前正在读取的线程数量，清0）

1.乐观读

tryOptimisticRead()：如果当前没有写锁占用，返回state(后7位清0，即清0读线程数)，如果有写锁，返回0，即失败。

2.校验stamp

校验这个戳是否有效validate()：比较当前stamp和发生乐观锁得到的stamp比较，不一致则失败。

3.悲观读

乐观锁失败后锁升级为readLock()：尝试state+1,用于统计读线程的数量，如果失败，进入acquireRead()进行自旋，通过CAS获取锁。如果自旋失败，入CLH队列，然后再自旋，如果成功获得读锁，激活cowait队列中的读线程Unsafe.unpark(),最终依然失败，Unsafe().park()挂起当前线程。

4.排它写

writeLock()：典型的cas操作，如果STATE等于s,设置写锁位为1（s+WBIT）。acquireWrite跟acquireRead逻辑类似，先自旋尝试、加入等待队列、直至最终Unsafe.park()挂起线程。

5.释放锁

unlockWrite():释放锁与加锁动作相反。将写标记位清零，如果state溢出，则退回到初始值；

性能和建议：JDK8之后才有，当高并发下且读远大于写时，由于可以乐观读，性能极高！

5.总结

4种锁，最稳定是内置synchronized锁（并不是完全被替代），当并发量大且读远大于写的情况下最快的的是StampedLock锁（乐观读。近似于无锁）。建议大家采用。

====================

参考：《JAVA高并发程序设计》