Java8 StampedLock（一）源码解析

最新推荐文章于 2024-05-04 13:48:30 发布

孙大圣666

最新推荐文章于 2024-05-04 13:48:30 发布

阅读量1.9k

点赞数 2

分类专栏： java8并发工具类源码解析文章标签： StampedLock 乐观读锁

本文链接：https://blog.csdn.net/qq_31865983/article/details/105324542

版权

java8并发工具类源码解析专栏收录该内容

35 篇文章 63 订阅

订阅专栏

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().getName()+" do something end for read,time->"+System.currentTimeMillis());
                    try{
                        //写锁必须等待所有的读锁释放才能获取锁，此处是读锁获取完成，等待获取写锁
                        //就形成了死锁
                        writeLock.lock();
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName()+" do something end for write,time->"+System.currentTimeMillis());
                    }finally {
                        writeLock.unlock();
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    readLock.unlock();
                    writeCount.countDown();
                }

            }
        };
        for(int i=0;i<5;i++){
            new Thread(a).start();
        }
        long start=System.currentTimeMillis();
        writeCount.await();
        System.out.println("read end,time->"+(System.currentTimeMillis()-start));
    }

    @Test
    public void test3() 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 {
                    writeLock.lock();
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName()+" do something end for write,time->"+System.currentTimeMillis());
                    try{
                        //StampedLock下同一线程已经获取了写锁，不能再获取读锁，必须等待写锁释放
                        readLock.lock();
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName()+" do something end for read,time->"+System.currentTimeMillis());
                    }finally {
                        readLock.unlock();
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    writeLock.unlock();
                    writeCount.countDown();
                }

            }
        };
        for(int i=0;i<5;i++){
            new Thread(a).start();
        }
        long start=System.currentTimeMillis();
        writeCount.await();
        System.out.println("write end,time->"+(System.currentTimeMillis()-start));
    }

    @Test
    public void test4() throws Exception {
        StampedLock lock=new StampedLock();
        Lock readLock=lock.asReadLock();
        Lock writeLock=lock.asWriteLock();
        CountDownLatch writeCount=new CountDownLatch(2);
        Thread a=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
                try {
                    writeLock.lock();
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName()+" do something end for write,time->"+System.currentTimeMillis());
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    writeLock.unlock();
                    writeCount.countDown();
                }

            }
        });
        //让线程a先运行起来，持有写锁并sleep
        a.start();
        Thread.sleep(100);
        Thread b=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
                try {
                    //必须得等待占有写锁的线程释放写锁，才能获取读锁
                    readLock.lock();
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName()+" do something end for read,time->"+System.currentTimeMillis());
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    readLock.unlock();
                    writeCount.countDown();
                }

            }
        });
        b.start();
        long start=System.currentTimeMillis();
        writeCount.await();
        System.out.println("main end,time->"+(System.currentTimeMillis()-start));
    }

    @Test
    public void test5() throws Exception {
        StampedLock lock=new StampedLock();
        Lock readLock=lock.asReadLock();
        Lock writeLock=lock.asWriteLock();
        CountDownLatch writeCount=new CountDownLatch(2);
        Thread a=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
                try {
                    readLock.lock();
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName()+" do something end for read,time->"+System.currentTimeMillis());
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    readLock.unlock();
                    writeCount.countDown();
                }

            }
        });
        //让线程a先运行起来，持有读锁并sleep
        a.start();
        Thread.sleep(100);
        Thread b=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
                try {
                    //其他线程占有读锁，必须等待读锁释放才能获取写锁
                    writeLock.lock();
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName()+" do something end for write,time->"+System.currentTimeMillis());
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    writeLock.unlock();
                    writeCount.countDown();
                }

            }
        });
        b.start();
        long start=System.currentTimeMillis();
        writeCount.await();
        System.out.println("main end,time->"+(System.currentTimeMillis()-start));
    }

通过上述测试用例可知，StampedLock同ReentrantReadWriteLock在实现锁的语义上略有不同，StampedLock下读锁和写锁是完全互斥的，无论是否同一个线程占有的，获取其中一个锁的前提是另一个锁必须释放掉，而ReentrantReadWriteLock是不完全互斥的，如果一个线程持有写锁可以再次获取读锁的，其他线程无法获取读锁。

2、锁重入

StampedLock下写锁是不可重入的，读锁是可重入的，而ReentrantReadWriteLock的读写锁都支持重入，参考如下测试用例：

@Test
    public void test6() throws Exception {
        StampedLock stampedLock=new StampedLock();
        Lock lock=stampedLock.asWriteLock();
        CountDownLatch writeCount=new CountDownLatch(1);
        Thread a=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
                try {
                    lock.lock();
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName()+" do something end for write,time->"+System.currentTimeMillis());
                    System.out.println("isWriteLocked->"+stampedLock.isWriteLocked());
                    try{
                        //写锁无法重入，此处形成死锁
                        lock.lock();
                        System.out.println(stampedLock.getReadLockCount());
                        Thread.sleep(2000);
                    }finally {
                        lock.unlock();
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                    writeCount.countDown();
                }

            }
        });
        //让线程a先运行起来，持有读锁并sleep
        a.start();
        long start=System.currentTimeMillis();
        writeCount.await();
        System.out.println("main end,time->"+(System.currentTimeMillis()-start));
    }

    @Test
    public void test7() throws Exception {
        StampedLock stampedLock=new StampedLock();
        Lock lock=stampedLock.asReadLock();
        CountDownLatch writeCount=new CountDownLatch(1);
        Thread a=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
                try {
                    lock.lock();
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName()+" do something end for read,time->"+System.currentTimeMillis());
                    try{
                        lock.lock();
                        //是否获取读锁
                        System.out.println("isReadLocked->"+stampedLock.isReadLocked());
                        //获取读锁重入次数
                        System.out.println("getReadLockCount->"+stampedLock.getReadLockCount());
                        Thread.sleep(2000);
                    }finally {
                        lock.unlock();
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                    writeCount.countDown();
                }

            }
        });
        //让线程a先运行起来，持有读锁并sleep
        a.start();
        long start=System.currentTimeMillis();
        writeCount.await();
        System.out.println("main end,time->"+(System.currentTimeMillis()-start));
    }

3、非公平锁

ReentrantReadWriteLock的读写锁都支持公平锁和非公平锁两种模式，默认是非公平锁，而StampedLock只支持非公平锁，参考如下测试用例：

 @Test
    public void test8() throws Exception {
         //StampedLock只支持非公平锁
//        ReadWriteLock readWriteLock=new StampedLock().asReadWriteLock();
        //默认的非公平锁
//        ReadWriteLock readWriteLock=new ReentrantReadWriteLock();
        //公平锁模式
        ReadWriteLock readWriteLock=new ReentrantReadWriteLock(true);
        Lock lock=readWriteLock.writeLock();
        CountDownLatch countDownLatch=new CountDownLatch(6);
        CyclicBarrier cyclicBarrier=new CyclicBarrier(4);
        Thread a=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" start,time->"+System.nanoTime());
                try {
                    lock.lock();
                    Thread.sleep(5000);
                    System.out.println(Thread.currentThread().getName()+" do something end for write,time->"+System.nanoTime());
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                    try {
                        cyclicBarrier.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }

            }
        });
        //让线程a先运行起来，持有读锁并sleep
        a.start();
        Thread.sleep(100);
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" start,time->"+System.nanoTime());
                try {
                    lock.lock();
                    System.out.println(Thread.currentThread().getName()+" get lock,time->"+System.nanoTime());
                } finally {
                    lock.unlock();
                    countDownLatch.countDown();
                }
            }
        };
        //这3个线程肯定都已经加入到同步链表中
        for(int i=0;i<3;i++){
            Thread thread=new Thread(runnable);
            thread.start();
        }
        Thread.sleep(100);
        Runnable runnable2=new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" start,time->"+System.nanoTime());
                try {
                    cyclicBarrier.await();
                    lock.lock();
                    System.out.println(Thread.currentThread().getName()+" get lock,time->"+System.nanoTime());
                } catch (Exception e){
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                    countDownLatch.countDown();
                }
            }
        };
        //这3个线程会在cyclicBarrier上等待，线程a释放锁后，这三个线程就会与已经在链表中的3个线程竞争锁
        for(int i=0;i<3;i++){
            Thread thread=new Thread(runnable2);
            thread.start();
        }
        Thread.sleep(100);
        countDownLatch.await();
        System.out.println("main end");
    }

在ReentrantReadWriteLock 公平锁模式下运行的结果如下：

Thread-0 start,time->2431564443282691
//1,2,3三个线程会进入同步链表中
Thread-1 start,time->2431564542902209
Thread-2 start,time->2431564542943641
Thread-3 start,time->2431564543006405
//4,5,6三个线程在cyclicBarrier上等待
Thread-4 start,time->2431564643196134
Thread-5 start,time->2431564643249053
Thread-6 start,time->2431564643370479
//0号线程准备释放锁了，释放完成后会唤醒在cyclicBarrier上等待的3个线程去抢占锁
//因为是公平锁，这3个线程会依次加入到同步链表中，插入到3的后面
//与此同时最早加入到同步链表中的1号线程会被唤醒抢占锁
Thread-0 do something end for write,time->2431569442882313
//各线程完全按照加入同步链表的顺序获取锁
Thread-1 get lock,time->2431569443096449
Thread-2 get lock,time->2431569443195724
Thread-3 get lock,time->2431569443290075
Thread-4 get lock,time->2431569443413552
Thread-5 get lock,time->2431569443552618
Thread-6 get lock,time->2431569443628920
main end

在ReentrantReadWriteLock非公平锁下输出如下：

Thread-0 start,time->2431720679333140
Thread-1 start,time->2431720770827359
Thread-2 start,time->2431720770922121
Thread-3 start,time->2431720770826129
Thread-4 start,time->2431720870806643
Thread-5 start,time->2431720870997397
Thread-6 start,time->2431720871033907
//非公平锁下，0号线程释放锁后就是同步链表头的的1号线程和此时几乎同步被唤醒的4,5,6三个线程
//竞争锁
Thread-0 do something end for write,time->2431725678408086
//已经加入到同步链表的1,2,3号线程获取锁的顺序跟加入链表的顺序一致
//5号线程是才开始抢占锁的但是优先于2,3号线程获取锁，即非公平锁的体现了
//4,5,6三个线程获取锁的顺序是底层进程调度决定的，每次运行的结果可能都不同
Thread-1 get lock,time->2431725678689500
Thread-5 get lock,time->2431725678812977
Thread-2 get lock,time->2431725678936864
Thread-3 get lock,time->2431725679055419
Thread-4 get lock,time->2431725679219508
Thread-6 get lock,time->2431725679442260
main end

在StampedLock非公平锁下输出稍有不同，已经加入到链表中的1,2,3号线程并不是按照加入到同步链表的顺序获取锁，其输出如下：

Thread-0 start,time->2432129070650348
Thread-1 start,time->2432129169911740
Thread-2 start,time->2432129169943738
Thread-3 start,time->2432129170014706
Thread-4 start,time->2432129270062087
Thread-6 start,time->2432129270395599
Thread-5 start,time->2432129270522358
Thread-0 do something end for write,time->2432134069706423
//1,2,3三个线程获取锁的顺序是不固定的，跟加入到同步链表的顺序无关
//4号线程优先于1,3号线程获取锁就是非公平锁的体现
//4,5,6获取锁的顺序同样是由底层进程调度决定的
Thread-2 get lock,time->2432134069941481
Thread-4 get lock,time->2432134070055524
Thread-1 get lock,time->2432134070219203
Thread-3 get lock,time->2432134070329553
Thread-6 get lock,time->2432134070453030
Thread-5 get lock,time->2432134070651168
main end

这是因为StampedLock在把当前线程加入到同步链表前都做了自旋等待，只有自旋等待的次数达到最大值了才会加入到同步链表中，因为底层系统调度的原因，1,2,3号线程自旋达到最大次数的先后顺序不一定是线程启动的顺序，即不会按照线程启动的顺序加入到同步链表中，获取锁时是按照实际加入到同步链表的顺序获取的。如果把这三个线程的启动时间间隔拉大，启动一个线程后就休眠200ms，则会按照线程启动的顺序加入到同步链表中，并按照同步链表中的顺序获取锁，改动如下：

再执行效果就跟 ReentrantReadWriteLock非公平锁下的输出一样了。

4、乐观读锁

ReentrantReadWriteLock下写锁必须等待所有的读锁都释放了才能获取，在读线程比较多写线程比较少的情形下，这会导致写线程可能会长期等待，StampedLock为了解决这个问题引入了乐观读锁。乐观读锁实际并不是一个锁，也没有实际的加锁解锁逻辑，只是判断了下是否写锁被占有了，如果没有则读取某个全局共享变量到本地，如果被占有了，则获取正常的读锁，与之对应，称为悲观读锁。当读取某个全局变量到本地后或者在使用拷贝到本地的本地变量的过程中，可能这时写锁被占用了，数据被修改了，导致原来读取的数据就是有问题的，调用方需要评估这种可能的数据不一致问题对业务的影响，测试用例如下：

@Test
    public void test9() throws Exception {
        ReentrantReadWriteLock readWriteLock=new ReentrantReadWriteLock();
        Lock readLock=readWriteLock.readLock();
        Lock writeLock=readWriteLock.writeLock();
        CyclicBarrier cyclicBarrier=new CyclicBarrier(12);
        int num=10000000;
        Runnable read=new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                for(int i=0;i<num;i++) {
                    try {
                        readLock.lock();
                        Holder.getA();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        readLock.unlock();
                    }
                }
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
        for(int i=0;i<10;i++){
            Thread thread=new Thread(read);
            thread.start();
        }
        Runnable write=new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                for(int i=0;i<num;i++) {
                    try {
                        writeLock.lock();
                        Holder.add();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        writeLock.unlock();
                    }
                }
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
        Thread b=new Thread(write);
        b.start();
        cyclicBarrier.await();
        long start=System.currentTimeMillis();
        System.out.println("run start");
        cyclicBarrier.await();
        System.out.println("run end,time->"+(System.currentTimeMillis()-start));
    }

    @Test
    public void test10() throws Exception {
        StampedLock stampedLock=new StampedLock();
        CyclicBarrier cyclicBarrier=new CyclicBarrier(12);
        int num=10000000;
        Runnable read=new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                for(int i=0;i<num;i++) {
                    try {
                        long stamp=stampedLock.tryOptimisticRead();
                        //读取共享变量
                        int a=Holder.getA();
                        //validate方法返回false表示占有了写锁，共享变量可能变了
                        if(!stampedLock.validate(stamp)){
                            try {
                                //获取正常的悲观读锁，会阻塞等待修改完成，写锁释放
                                stamp=stampedLock.readLock();
                                //重新读取共享变量
                                a=Holder.getA();
                            } finally {
                                //释放读锁
                                stampedLock.unlockRead(stamp);
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
        for(int i=0;i<10;i++){
            Thread thread=new Thread(read);
            thread.start();
        }
        Runnable write=new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                for(int i=0;i<num;i++) {
                    long stamp=0;
                    try {
                        stamp=stampedLock.writeLock();
                        Holder.add();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        stampedLock.unlockWrite(stamp);
                    }
                }
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
        Thread b=new Thread(write);
        b.start();
        cyclicBarrier.await();
        long start=System.currentTimeMillis();
        System.out.println("run start");
        cyclicBarrier.await();
        System.out.println("run end,time->"+(System.currentTimeMillis()-start));
    }

test9耗时19s左右，test10耗时不足400ms，由此可见在读多写少的场景下，乐观读锁可以显著提供系统的处理效率，提高系统吞吐量，大幅减少锁等待的时间。

5、锁转换

StampedLock在正常的读写锁之外增加了乐观读锁，并支持在这三种锁之间有限的转换，所谓的转换就是不需要经过解锁直接加锁，避免代码冗余，具体如下：

1）转换成写锁的前提是从stamp对应的一次加锁到现在获取写锁的次数未发生改变，即这期间一直是读锁或者乐观读锁或者写锁一直未释放，然后满足以下条件之一：

当前状态是写锁，stamp也是写锁
当前状态是读锁，且锁重入次数只有一次，stamp占有读锁或者写锁
当前状态是乐观读锁，stamp是无锁状态

测试用例如下：

 @Test
    public void test11() throws Exception {
        StampedLock stampedLock=new StampedLock();
        long stamp=0;
        try {
            stamp=stampedLock.readLock();
            System.out.println("get readLock succ");
            //此时会直接释放读锁并获取写锁
            long result=stampedLock.tryConvertToWriteLock(stamp);
            if(result==0){
                System.out.println("tryConvertToWriteLock fail");
                stampedLock.unlockRead(stamp);
                stamp=stampedLock.writeLock();
            }else{
                stamp=result;
            }
            System.out.println("get writeLock succ");
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }

    @Test
    public void test12() throws Exception {
        StampedLock stampedLock=new StampedLock();
        long stamp=0;
        try {
            stamp=stampedLock.readLock();
            long stamp2=stampedLock.readLock();
            System.out.println("get readLock succ");
            //此时会直接释放读锁并获取写锁
            long stamp3=stampedLock.tryConvertToWriteLock(stamp2);
            if(stamp3==0){
                System.out.println("tryConvertToWriteLock fail");
                stampedLock.unlockRead(stamp2);
                stampedLock.unlockRead(stamp);
                stamp=stampedLock.writeLock();
            }
            System.out.println("get writeLock succ");
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }

    @Test
    public void test13() throws Exception {
        StampedLock stampedLock=new StampedLock();
        long stamp=0;
        try {
            stamp=stampedLock.tryOptimisticRead();
            System.out.println("get OptimisticRead succ");
            //此时会直接释放读锁并获取写锁
            long result=stampedLock.tryConvertToWriteLock(stamp);
            if(result==0){
                System.out.println("tryConvertToWriteLock fail");
                stampedLock.unlockRead(stamp);
                stamp=stampedLock.writeLock();
            }else{
                stamp=result;
            }
            System.out.println("get writeLock succ");
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }

2) 转换成读锁的前提跟转换成写锁的前提一样，从stamp对应的一次加锁到现在获取写锁的次数未发生改变，然后满足以下条件之一：

当前是写锁，stamp也是写锁
当前是乐观读锁，stamp也是乐观读锁
当前是读锁，stamp也是读锁

测试用例如下：

@Test
    public void test15() throws Exception {
        StampedLock stampedLock=new StampedLock();
        long stamp=0;
        try {
            stamp=stampedLock.writeLock();
            System.out.println("get writeLock succ");
            //此时会直接释放写锁，获取读锁，然后唤醒下一个等待写锁的线程
            long result=stampedLock.tryConvertToReadLock(stamp);
            if(result==0){
                System.out.println("tryConvertToReadLock fail");
                stampedLock.unlockWrite(stamp);
                stamp=stampedLock.readLock();
            }else{
                stamp=result;
            }
            System.out.println("get readLock succ");
        } finally {
            stampedLock.unlockRead(stamp);
        }
    }

    @Test
    public void test16() throws Exception {
        StampedLock stampedLock=new StampedLock();
        long stamp=0;
        try {
            stamp=stampedLock.tryOptimisticRead();
            System.out.println("get writeLock succ");
            //此时会直接释放写锁，获取读锁，然后唤醒下一个等待写锁的线程
            long result=stampedLock.tryConvertToReadLock(stamp);
            if(result==0){
                System.out.println("tryConvertToReadLock fail");
                stamp=stampedLock.readLock();
            }else{
                stamp=result;
            }
            System.out.println("get readLock succ");
        } finally {
            stampedLock.unlockRead(stamp);
        }
    }

3）转换成乐观读锁的前提跟转换成写锁的前提一样，从stamp对应的一次加锁到现在获取写锁的次数未发生改变，然后满足以下条件之一：

stamp和当前的锁都是写锁或者读锁，会释放锁
stamp和当前的锁都是乐观读锁

测试用例如下：

@Test
    public void test17() throws Exception {
        StampedLock stampedLock=new StampedLock();
        long stamp=0;
        try {
            stamp=stampedLock.writeLock();
            System.out.println("get writeLock succ");
            //此时会直接释放写锁，获取读锁，然后唤醒下一个等待写锁的线程
            long result=stampedLock.tryConvertToOptimisticRead(stamp);
            if(result==0){
                System.out.println("tryConvertToOptimisticRead fail");
                stampedLock.unlockWrite(stamp);
                stamp=stampedLock.tryOptimisticRead();
            }else{
                stamp=result;
            }
            System.out.println("get OptimisticRead succ");
        } finally {
            System.out.println(""+stampedLock.validate(stamp));
        }
    }

    @Test
    public void test18() throws Exception {
        StampedLock stampedLock=new StampedLock();
        long stamp=0;
        try {
            stamp=stampedLock.readLock();
            System.out.println("get readLock succ");
            //此时会直接释放写锁，获取读锁，然后唤醒下一个等待写锁的线程
            long result=stampedLock.tryConvertToOptimisticRead(stamp);
            if(result==0){
                System.out.println("tryConvertToOptimisticRead fail");
                stampedLock.unlockRead(stamp);
                stamp=stampedLock.tryOptimisticRead();
            }else{
                stamp=result;
            }
            System.out.println("get OptimisticRead succ");
        } finally {
            System.out.println(""+stampedLock.validate(stamp));
        }
    }

孙大圣666

关注

2
点赞
踩
27

收藏

觉得还不错? 一键收藏
1
评论
Java8 StampedLock（一）源码解析

目录一、定义二、使用1、读写锁2、锁重入3、非公平锁4、乐观读锁5、锁转换StampedLock是Java8引入的，对ReentrantReadWriteLock的一个改良和扩展，其底层实现不再基于AbstractQueuedSynchronizer了，本篇博客就来详细探讨该类的定义和使用。一、定义 StampedLock没有直接实现ReadWri...
复制链接

扫一扫