devbox
酷酷是懒虫
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

ReentrantReadWriteLock读写锁的使用_reentrantreadwritelock.writelock[]

作者：酷酷是懒虫 | 2024-08-10 01:15:13

赞

踩

reentrantreadwritelock.writelock[]

类ReentrantLock具有完全互斥排他的效果，即同一时间只有一个线程在执行ReentrantLock.lock()后面的代码。这样虽然保证了线程的安全性，但是效率低下。JDK提供了ReentrantReadWriteLock读写锁，使用它可以加快效率，在某些不需要操作实例变量的方法中，完全可以使用读写锁ReemtrantReadWriteLock来提升该方法的运行速度。

　　读写锁表示有两个锁，一个是读操作相关的锁，也称为共享锁；另一个是写操作相关的锁，也叫排他锁。也就是多个读锁之间不互斥，读锁与写锁互斥、写锁与写锁互斥。在没有线程Thread进行写入操作时，进行读取操作的多个Thread都可以获取读锁，而进行写入操作的Thread只有在获取写锁后才能进行写入操作。即多个Thread可以同时进行读取操作，但是同一时刻只允许一个Thread进行写入操作。
 

1.读读共享

　　读锁与读锁可以共享，这种锁一般用于只读操作，不对变量进行修改操作。

  1. package cn.qlq.thread.twelve;
  2.  
  3. import java.util.concurrent.locks.ReentrantReadWriteLock;
  4.  
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7.  
  8. import cn.qlq.thread.one.RunnableThread;
  9.  
  10. public class Demo1 {
  11.     private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();// 读写锁
  12.     private static final Logger log = LoggerFactory.getLogger(Demo1.class);
  13.  
  14.     private int i;
  15.  
  16.     public String readI() {
  17.         try {
  18.             lock.readLock().lock();// 占用读锁
  19.             log.info("threadName -> {} 占用读锁,i->{}", Thread.currentThread().getName(), i);
  20.             Thread.sleep(2 * 1000);
  21.         } catch (InterruptedException e) {
  22.  
  23.         } finally {
  24.             log.info("threadName -> {} 释放读锁,i->{}", Thread.currentThread().getName(), i);
  25.             lock.readLock().unlock();// 释放读锁
  26.         }
  27.         return i + "";
  28.     }
  29.  
  30.     public static void main(String[] args) {
  31.         final Demo1 demo1 = new Demo1();
  32.         Runnable runnable = new Runnable() {
  33.             @Override
  34.             public void run() {
  35.                 demo1.readI();
  36.             }
  37.         };
  38.  
  39.         new Thread(runnable, "t1").start();
  40.         new Thread(runnable, "t2").start();
  41.         new Thread(runnable, "t3").start();
  42.  
  43.     }
  44.  
  45. }

 

结果:

18:27:20 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t2 占用读锁,i->0
18:27:20 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t1 占用读锁,i->0
18:27:20 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t3 占用读锁,i->0
18:27:22 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t3 释放读锁,i->0
18:27:22 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t1 释放读锁,i->0
18:27:22 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t2 释放读锁,i->0

 

2.写写互斥

　　写锁与写锁互斥，这就类似于ReentrantLock的作用效果。

 
  1. package cn.qlq.thread.twelve;
  2.  
  3. import java.util.concurrent.locks.ReentrantReadWriteLock;
  4.  
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7.  
  8. public class Demo2 {
  9.     private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();// 读写锁
  10.     private static final Logger log = LoggerFactory.getLogger(Demo2.class);
  11.  
  12.     private int i;
  13.  
  14.     public void addI() {
  15.         try {
  16.             lock.writeLock().lock();// 占用写锁
  17.             log.info("threadName -> {} 占用写锁,i->{}", Thread.currentThread().getName(), i);
  18.             Thread.sleep(2 * 1000);
  19.             i++;
  20.         } catch (InterruptedException e) {
  21.  
  22.         } finally {
  23.             log.info("threadName -> {} 释放写锁,i->{}", Thread.currentThread().getName(), i);
  24.             lock.writeLock().unlock();// 释放写锁
  25.         }
  26.     }
  27.  
  28.     public static void main(String[] args) {
  29.         final Demo2 demo1 = new Demo2();
  30.         Runnable runnable = new Runnable() {
  31.             @Override
  32.             public void run() {
  33.                 demo1.addI();
  34.             }
  35.         };
  36.  
  37.         new Thread(runnable, "t1").start();
  38.         new Thread(runnable, "t2").start();
  39.         new Thread(runnable, "t3").start();
  40.  
  41.     }
  42.  
  43. }
  44.  
  45.

 

结果:(从时间可以看出实现了互斥效果)

18:31:31 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t1 占用写锁,i->0
18:31:33 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t1 释放写锁,i->1
18:31:33 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t2 占用写锁,i->1
18:31:35 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t2 释放写锁,i->2
18:31:35 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t3 占用写锁,i->2
18:31:37 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t3 释放写锁,i->3

3.读写互斥

  1. package cn.qlq.thread.twelve;
  2.  
  3. import java.util.concurrent.locks.ReentrantReadWriteLock;
  4.  
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7.  
  8. /**
  9.  * 读写互斥
  10.  * 
  11.  * @author Administrator
  12.  *
  13.  */
  14. public class Demo3 {
  15.     private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();// 读写锁
  16.     private static final Logger log = LoggerFactory.getLogger(Demo3.class);
  17.  
  18.     private int i;
  19.  
  20.     public String readI() {
  21.         try {
  22.             lock.readLock().lock();// 占用读锁
  23.             log.info("threadName -> {} 占用读锁,i->{}", Thread.currentThread().getName(), i);
  24.             Thread.sleep(2 * 1000);
  25.         } catch (InterruptedException e) {
  26.  
  27.         } finally {
  28.             log.info("threadName -> {} 释放读锁,i->{}", Thread.currentThread().getName(), i);
  29.             lock.readLock().unlock();// 释放读锁
  30.         }
  31.         return i + "";
  32.     }
  33.  
  34.     public void addI() {
  35.         try {
  36.             lock.writeLock().lock();// 占用写锁
  37.             log.info("threadName -> {} 占用写锁,i->{}", Thread.currentThread().getName(), i);
  38.             Thread.sleep(2 * 1000);
  39.             i++;
  40.         } catch (InterruptedException e) {
  41.  
  42.         } finally {
  43.             log.info("threadName -> {} 释放写锁,i->{}", Thread.currentThread().getName(), i);
  44.             lock.writeLock().unlock();// 释放写锁
  45.         }
  46.     }
  47.  
  48.     public static void main(String[] args) throws InterruptedException {
  49.         final Demo3 demo1 = new Demo3();
  50.  
  51.         new Thread(new Runnable() {
  52.             @Override
  53.             public void run() {
  54.                 demo1.readI();
  55.             }
  56.         }, "t1").start();
  57.  
  58.         Thread.sleep(1 * 1000);
  59.  
  60.         new Thread(new Runnable() {
  61.             @Override
  62.             public void run() {
  63.                 demo1.addI();
  64.             }
  65.         }, "t2").start();
  66.  
  67.     }
  68.  
  69. }

结果:

18:34:59 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t1 占用读锁,i->0
18:35:01 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t1 释放读锁,i->0
18:35:01 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t2 占用写锁,i->0
18:35:03 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t2 释放写锁,i->1

 

4.写读互斥

　　写锁与读锁也是互斥的。先占用写锁后读锁进行抢占也会等待写锁释放。

  1. package cn.qlq.thread.twelve;
  2.  
  3. import java.util.concurrent.locks.ReentrantReadWriteLock;
  4.  
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7.  
  8. /**
  9.  * 读写互斥
  10.  * 
  11.  * @author Administrator
  12.  *
  13.  */
  14. public class Demo3 {
  15.     private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();// 读写锁
  16.     private static final Logger log = LoggerFactory.getLogger(Demo3.class);
  17.  
  18.     private int i;
  19.  
  20.     public String readI() {
  21.         try {
  22.             lock.readLock().lock();// 占用读锁
  23.             log.info("threadName -> {} 占用读锁,i->{}", Thread.currentThread().getName(), i);
  24.             Thread.sleep(2 * 1000);
  25.         } catch (InterruptedException e) {
  26.  
  27.         } finally {
  28.             log.info("threadName -> {} 释放读锁,i->{}", Thread.currentThread().getName(), i);
  29.             lock.readLock().unlock();// 释放读锁
  30.         }
  31.         return i + "";
  32.     }
  33.  
  34.     public void addI() {
  35.         try {
  36.             lock.writeLock().lock();// 占用写锁
  37.             log.info("threadName -> {} 占用写锁,i->{}", Thread.currentThread().getName(), i);
  38.             Thread.sleep(2 * 1000);
  39.             i++;
  40.         } catch (InterruptedException e) {
  41.  
  42.         } finally {
  43.             log.info("threadName -> {} 释放写锁,i->{}", Thread.currentThread().getName(), i);
  44.             lock.writeLock().unlock();// 释放写锁
  45.         }
  46.     }
  47.  
  48.     public static void main(String[] args) throws InterruptedException {
  49.         final Demo3 demo1 = new Demo3();
  50.  
  51.         new Thread(new Runnable() {
  52.             @Override
  53.             public void run() {
  54.                 demo1.addI();
  55.             }
  56.         }, "t2").start();
  57.  
  58.         Thread.sleep(1 * 1000);
  59.  
  60.         new Thread(new Runnable() {
  61.             @Override
  62.             public void run() {
  63.                 demo1.readI();
  64.             }
  65.         }, "t1").start();
  66.     }
  67.  
  68. }
 

 

结果:

18:36:14 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t2 占用写锁,i->0
18:36:16 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t2 释放写锁,i->1
18:36:16 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t1 占用读锁,i->1
18:36:18 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t1 释放读锁,i->1

 

总结:　读写、写读、写写都是互斥的，而读读是异步非互斥的。

　　    也就是只要有写锁的参与就会进行同步，所以写锁也被称为排他锁，读锁被称为共享锁。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/酷酷是懒虫/article/detail/956085
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号