读写锁ReentrantReadWriteLock用法详解

前言

业务开发中我们可能涉及到读写操作。
面对写和读，对于数据同步，在使用Lock锁和synchronized关键字同步数据时候，对于读读而言，两个线程也需要争抢锁，此时额外争抢锁是没有意义的，造成性能损耗，写的时候，不能读，没有写的时候，读线程不能互斥。

对于Lock锁和synchronized 来说。都是互斥锁，读读也存在互斥。对此，我们需要读写锁。

如实例：

生产者和消费者而言

当一个线程负责生产，2个线程负责消费，生产者没有进行生产时，两个消费线程都可以去消费数据(这里我们不考虑 重复数据问题)

两个线程彼此还要争抢资源

privatestaticfinalint LINED_SIZE=1000;privatestaticint num=0;privatestaticfinalObject lock=newObject();privatestaticfinalLinkedList<Integer> linkedList=newLinkedList<>();publicstaticvoidmain(String[] args)throwsInterruptedException{




        t1.start();
        t2.start();
        t3.start();

        t1.setPriority(5);
        t2.setPriority(5);
        t3.setPriority(5);

        t1.join();
        t2.join();
        t3.join();TimeUnit.SECONDS.sleep(2);System.out.println(" main  end ");}staticclassConsumerObjeimplementsRunnable{@Overridepublicvoidrun(){while(true){synchronized(lock){while(linkedList.size()==0){try{
                           lock.wait();}catch(InterruptedException e){
                           e.printStackTrace();}}try{Thread.sleep(5_00);}catch(InterruptedException e){
                       e.printStackTrace();}System.out.println(Thread.currentThread().getName()+" : "+ linkedList.removeFirst());
                   lock.notifyAll();}}}}staticclassProductObjeimplementsRunnable{@Overridepublicvoidrun(){while(true){synchronized(lock){while(linkedList.size()>= LINED_SIZE){try{
                            lock.wait();}catch(InterruptedException e){
                            e.printStackTrace();}}int n= num++;System.out.println(" 正在生产: "+ n);
                    linkedList.addLast(n);
                    lock.notifyAll();}}}}

思考

• 为什么需要使用读写锁ReentrantReadWriteLock

• 这个锁有什么好处？缺点？

好处： 读读不能互斥，提升锁性能，减少线程竞争。
缺点是：当读锁过多时候，写锁少，存在锁饥饿现象。

读写锁ReentrantReadWriteLock用法详解

ReentrantReadWriteLock 也提供了公平和非公平锁

基于构造默认非公平锁, ReentrantReadWriteLock 读写锁内部也是基于AQS队列实现的。

publicReentrantReadWriteLock(){this(false);}

//读写锁privatestaticReentrantReadWriteLock readWriteLock=newReentrantReadWriteLock(true);//写锁privatefinalstaticLock writeLock= readWriteLock.writeLock();//读锁privatefinalstaticLock readLock= readWriteLock.readLock();privatefinalstaticList<Long> longs=newArrayList<>();publicfinalstaticvoidmain(String[] args)throwsInterruptedException{//        new Thread(ReentrantReadWriteLockTest::write).start();//        TimeUnit.SECONDS.sleep(1);//        new Thread(ReentrantReadWriteLockTest::write).start();newThread(ReentrantReadWriteLockTest::write).start();TimeUnit.SECONDS.sleep(1);newThread(ReentrantReadWriteLockTest::read).start();newThread(ReentrantReadWriteLockTest::read).start();}staticvoidwrite(){try{
            writeLock.lock();TimeUnit.SECONDS.sleep(1);System.out.println(Thread.currentThread().getName()+" write ");
            longs.add(System.currentTimeMillis());}catch(InterruptedException e){
            e.printStackTrace();}finally{
            writeLock.unlock();}}staticvoidread(){try{
            readLock.lock();TimeUnit.SECONDS.sleep(1);
            longs.forEach(x->System.out.println(x));}catch(InterruptedException e){
            e.printStackTrace();}finally{
            readLock.lock();}}

可以看到我们写了一条数据，两条数据同时打印出来，读读是不互斥的。

Thread-0 write
1648997092090
1648997092090

读写锁 存在一个问题:
当读锁比例很多,写锁很少,锁竞争情况下,写锁抢到锁的机会就回少,读锁数量太大的情况下,写锁不一定能抢到锁.

我们使用非公平锁，来测试，启动5个读锁，一个写锁。

//读写锁privatestaticReentrantReadWriteLock readWriteLock=newReentrantReadWriteLock(false);//写锁privatefinalstaticLock writeLock= readWriteLock.writeLock();//读锁privatefinalstaticLock readLock= readWriteLock.readLock();privatefinalstaticList<Long> longs=newArrayList<>();publicfinalstaticvoidmain(String[] args)throwsInterruptedException{newThread(ReentrantReadWriteLockTest2::write).start();TimeUnit.SECONDS.sleep(1);//new Thread(ReentrantReadWriteLockTest2::read).start();//new Thread(ReentrantReadWriteLockTest2::read).start();for(int i=0; i<5; i++){newThread(ReentrantReadWriteLockTest2::read).start();}}staticvoidwrite(){for(;;){try{
               writeLock.lock();TimeUnit.SECONDS.sleep(1);System.out.println(Thread.currentThread().getName()+" write ");
               longs.add(System.currentTimeMillis());}catch(InterruptedException e){
               e.printStackTrace();}finally{
               writeLock.unlock();}}}staticvoidread(){for(;;){try{
                  readLock.lock();TimeUnit.SECONDS.sleep(1);
                  longs.forEach(x->System.out.println(x));}catch(InterruptedException e){
                  e.printStackTrace();}finally{
                  readLock.lock();}}}

测试结果这里就不写了，刚开始一直写，后来一直读，写锁机会很少，当读线程比例再大时，写的机会就更少了。

最后

ReentrantReadWriteLock 读写锁既有有点也有缺点

好处： 读读不能互斥，提升锁性能，减少线程竞争。
缺点是：当读锁过多时候，写锁少，存在锁饥饿现象。

使用时候需要控制读写比例，防止出现锁饥饿现象。

当出现读比例特别大时候，ReentrantReadWriteLock锁就不适合了，此时JDK8之后提供的StampedLock锁更适合读写比例大的场景