目录
StampedLock是Java8引入的,对ReentrantReadWriteLock的一个改良和扩展,其底层实现不再基于AbstractQueuedSynchronizer了,本篇博客就来详细探讨该类的定义和使用。
一、定义
StampedLock没有直接实现ReadWriteLock,但是提供了方法可以返回ReadWriteLock接口的实现类,如下:
可以通过asReadWriteLock方法与之前使用ReentrantReadWriteLock无缝兼容,也可以通过asReadLock和asWriteLock方法单独使用读锁或者写锁。
StampedLock定义了多个内部类,如下:
ReadLockView和WriteLockView都实现了Lock接口,前者用于实现读锁,asReadLock方法就返回该类的实例;后者用于实现写锁,asWriteLock就返回该类的实例;ReadWriteLockView实现了ReadWriteLock接口,asReadWriteLock接口就返回该类的实例。这三个类的实现基于StampedLock的public方法的。如下:
注意ReadLockView和WriteLockView的newCondition方法的实现都是抛出UnsupportedOperationException异常,因为StampedLock提供Condition接口的实现类,不过正常使用Condition接口都是直接使用ReentrantLock。
上面的WNode和AbstractQueuedSynchronizer的内部类Node基本一样,其定义如下:
Node中使用nextWaiter属性来记录锁的模式,这里单列了一个字段mode;status属性对应于Node中的waitStatus属性,cowait属性用来构成一个等待获取读锁的WNode链表,通过遍历这个链表就可以获取在此节点之后请求读锁的所有线程,避免遍历同步链表时判断是否读锁节点;其他三个字段和Node中的含义一样。
StampedLock中定义了多个常量,如下:
/**CPU的个数,用来判断自旋次数*/
private static final int NCPU = Runtime.getRuntime().availableProcessors();
/** 加入等待链表前自旋的最大次数,如果是多核,则最多自旋64次 */
private static final int SPINS = (NCPU > 1) ? 1 << 6 : 0;
/** 等待head节点释放锁时第一轮for循环自旋(自旋通过内层的for循环实现)的最大次数,如果是多核,则最多自旋1024次
如果还是无法获取锁,则进入第二轮for循环,自旋的最大次数扩容一倍,直到达到
MAX_HEAD_SPINS为止不再扩容 */
private static final int HEAD_SPINS = (NCPU > 1) ? 1 << 10 : 0;
/** 等待head节点释放锁时一轮for循环自旋的最大次数,则最多自旋65536次 */
private static final int MAX_HEAD_SPINS = (NCPU > 1) ? 1 << 16 : 0;
/** 执行yeild的周期 */
private static final int OVERFLOW_YIELD_RATE = 7; // must be power 2 - 1
/** 用来记录读锁重入次数的位数,第7位之后的位用来记录累计获取写锁的次数 */
private static final int LG_READERS = 7;
//获取读锁成功后state加上RUNIT
private static final long RUNIT = 1L;
//获取写锁和释放写锁成功后需要将state加上WBIT,然后通过第8位的位是否为1判断是否占有写锁
private static final long WBIT = 1L << LG_READERS;
//RBITS表示重入读锁的理论最大次数了,就是7个1,即127
private static final long RBITS = WBIT - 1L;
//实际允许重入读锁的最大次数,即126
private static final long RFULL = RBITS - 1L;
//ABITS就是8个1,将state与之求且,如果结果为0则表示此时读锁和写锁都没有被占用
//如果结果大于WBIT,即第8位为1,表示写锁被占有了
//如果结果等于RFULL则说明读锁重入的次数达到最大值了,多余次数通过readerOverflow属性记录
private static final long ABITS = RBITS | WBIT;
//前57位是1,后7位是0,将state与之求且可以获取获取写锁的累计次数
private static final long SBITS = ~RBITS; // note overlap with ABITS
//初始值
private static final long ORIGIN = WBIT << 1;
//线程被中断后返回的特殊值
private static final long INTERRUPTED = 1L;
//WNode节点的状态,初始是0
private static final int WAITING = -1;
private static final int CANCELLED = 1;
//读锁和写锁对应的模式
private static final int RMODE = 0;
private static final int WMODE = 1;
StampedLock包含的实例属性如下:
/** 同步链表头 */
private transient volatile WNode whead;
/** 同步链表尾 */
private transient volatile WNode wtail;
// 实现读写锁接口的实例
transient ReadLockView readLockView;
transient WriteLockView writeLockView;
transient ReadWriteLockView readWriteLockView;
/** 记录锁的状态 */
private transient volatile long state;
/** 读锁重入次数达到最大值后,记录超过最大值的次数*/
private transient int readerOverflow;
StampedLock包含的静态属性都是通过static代码块初始化,都是些关键属性的偏移量,用来实现原子的修改属性值,如下:
二、使用
1、读写锁
StampedLock本身是为了优化ReentrantReadWriteLock的性能,其用法完全跟后者保持一致,可以借用后者的测试用例,如下:
@Test
public void test() throws Exception {
StampedLock lock=new StampedLock();
Lock readLock=lock.asReadLock();
CyclicBarrier cyclicBarrier=new CyclicBarrier(6);
Runnable a=new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
try {
readLock.lock();
Thread.sleep(1000);
System.out.println("do something end for read,time->"+System.currentTimeMillis());
cyclicBarrier.await();
}catch (Exception e){
e.printStackTrace();
}finally {
readLock.unlock();
}
}
};
for(int i=0;i<5;i++){
new Thread(a).start();
}
long start=System.currentTimeMillis();
cyclicBarrier.await();
System.out.println("read end,time->"+(System.currentTimeMillis()-start));
Lock writeLock=lock.asWriteLock();
Runnable b=new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
try {
writeLock.lock();
Thread.sleep(1000);
System.out.println("do something end for write,time->"+System.currentTimeMillis());
}catch (Exception e){
e.printStackTrace();
}finally {
writeLock.unlock();
try {
cyclicBarrier.await();
} catch (Exception e) {
e.printStackTrace();
}
}
}
};
for(int i=0;i<5;i++){
new Thread(b).start();
}
start=System.currentTimeMillis();
cyclicBarrier.await();
System.out.println("write end,time->"+(System.currentTimeMillis()-start));
}
@Test
public void test2() throws Exception {
StampedLock lock=new StampedLock();
Lock readLock=lock.asReadLock();
Lock writeLock=lock.asWriteLock();
CountDownLatch writeCount=new CountDownLatch(5);
Runnable a=new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
try {
readLock.lock();
Thread.sleep(1000);
System.out.println(Thread.currentThread()