1 简介
ReentrantLock和ReentrantReadWriteLock都是可重入锁。可重入锁，顾名思义，就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁
ReentrantLock和ReentrantReadWriteLock都支持获取锁时的公平和非公平性选择。默认是非公平的
ReentrantLock读读、读写、写写全部互斥。ReentrantReadWriteLock读读共享，读写互斥，写写互斥，且支持锁降级
ReentrantReadWriteLock由于读读共享，且支持锁降级，所及效率会高一些。由于它读写不共享，所以在读写高并发操作时，可能导致写的操作锁饥饿。
| 是否可重入 | 公平性选择 | 读读 | 读写 | 写写 | 锁降级 | |
| ReentrantLock | 是 | 是 | 互斥 | 互斥 | 互斥 | 不支持 |
| ReentrantReadWriteLock | 是 | 是 | 共享 | 互斥 | 互斥 | 支持 |
2 ReentrantLock示例
public class ReentrantLockTest1 { static ReentrantLock lo = new ReentrantLock(); //读读互斥 读写互斥 写写互斥 public static void main(String[] args) { for (int i = 0;i < 5;i++) { new Thread(() -> operate(), "要进行读操作的线程" + i).start(); } for (int i = 0;i < 5;i++) { new Thread(() -> operate(), "要进行写操作的线程线程" + i).start(); } } private static void operate() { lo.lock(); System.out.println(Thread.currentThread().getName() + "开始操作-----------"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "结束操作-----------"); lo.unlock(); } }
执行结果，只有执行完一个操作，才能够执行另一个操作，所有操作互斥
要进行读操作的线程0开始操作----------- 要进行读操作的线程0结束操作----------- 要进行读操作的线程1开始操作----------- 要进行读操作的线程1结束操作----------- 要进行读操作的线程2开始操作----------- 要进行读操作的线程2结束操作----------- 要进行读操作的线程3开始操作----------- 要进行读操作的线程3结束操作----------- 要进行读操作的线程4开始操作----------- 要进行读操作的线程4结束操作----------- 要进行写操作的线程线程0开始操作----------- 要进行写操作的线程线程0结束操作----------- 要进行写操作的线程线程1开始操作----------- 要进行写操作的线程线程1结束操作----------- 要进行写操作的线程线程2开始操作----------- 要进行写操作的线程线程2结束操作----------- 要进行写操作的线程线程3开始操作----------- 要进行写操作的线程线程3结束操作----------- 要进行写操作的线程线程4开始操作----------- 要进行写操作的线程线程4结束操作----------- Process finished with exit code 0
3 ReentrantReadWriteLock 示例
ReentrantReadWriteLock分为：
读锁-ReentrantReadWriteLock.ReadLock
写锁-ReentrantReadWriteLock.WriteLock
3.1 示例1
下面示例演示出了：读读不互斥，读写互斥，写写互斥
public class ReentrantLockTest2 { static ReentrantReadWriteLock lo = new ReentrantReadWriteLock(); static ReentrantReadWriteLock.ReadLock readLock = lo.readLock(); static ReentrantReadWriteLock.WriteLock writeLock = lo.writeLock(); public static void main(String[] args) { for (int i = 0;i < 10;i++) { new Thread(() -> read(), "read线程" + i).start(); } for (int i = 0;i < 10;i++) { new Thread(() -> write(), "write线程" + i).start(); } } private static void read() { readLock.lock(); System.out.println(Thread.currentThread().getName() + "开始读-----------"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "结束读-----------"); readLock.unlock(); } private static void write() { writeLock.lock(); System.out.println(Thread.currentThread().getName() + "开始写-----------"); try { Thread.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "结束写-----------"); writeLock.unlock(); } }
执行结果，发现多个读操作可以同时进行，读写操作互斥，写写也互斥
read线程0开始读----------- read线程4开始读----------- read线程3开始读----------- read线程1开始读----------- read线程2开始读----------- read线程0结束读----------- read线程3结束读----------- read线程4结束读----------- read线程1结束读----------- read线程2结束读----------- write线程0开始写----------- write线程0结束写----------- write线程1开始写----------- write线程1结束写----------- write线程2开始写----------- write线程2结束写----------- write线程3开始写----------- write线程3结束写----------- write线程4开始写----------- write线程4结束写----------- Process finished with exit code 0
3.2 示例2
这个示例是为了进一步演示读写互斥，和示例2相比，这里for循环先调用写，再调用的读，发现读写，还是互斥
public class ReentrantLockTest3 { static ReentrantReadWriteLock lo = new ReentrantReadWriteLock(); static ReentrantReadWriteLock.ReadLock readLock = lo.readLock(); static ReentrantReadWriteLock.WriteLock writeLock = lo.writeLock(); public static void main(String[] args) { for (int i = 0;i < 5;i++) { new Thread(() -> write(), "write线程" + i).start(); } for (int i = 0;i < 5;i++) { new Thread(() -> read(), "read线程" + i).start(); } } private static void read() { readLock.lock(); System.out.println(Thread.currentThread().getName() + "开始读-----------"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "结束读-----------"); readLock.unlock(); } private static void write() { writeLock.lock(); System.out.println(Thread.currentThread().getName() + "开始写-----------"); try { Thread.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "结束写-----------"); writeLock.unlock(); } }
执行结果
write线程0开始写----------- write线程0结束写----------- write线程1开始写----------- write线程1结束写----------- write线程2开始写----------- write线程2结束写----------- write线程3开始写----------- write线程3结束写----------- write线程4开始写----------- write线程4结束写----------- read线程0开始读----------- read线程1开始读----------- read线程2开始读----------- read线程4开始读----------- read线程3开始读----------- read线程4结束读----------- read线程1结束读----------- read线程2结束读----------- read线程0结束读----------- read线程3结束读----------- Process finished with exit code 0
4 ReentrantReadWriteLock锁降级
简单来说，就是一个线程在持有写锁，且还未释放的时候，可以去获取读锁，这样子，该线程就可以同时持有读写锁。
多个线程操作一个变量a，使用ReentrantReadWriteLock线程1对a进行修改，值为100，它想要保证100这个值被其它所有的线程获取到，该怎么做？
那么我们要去写的时候，先去获取写锁(此时其它线程不能读写)，写完了，再获取读锁(此时其它线程不能读写)，此时同时持有读写锁，然后释放写锁,只持有读锁((此时其它线程不能写,但是可以读))，这个从写锁变为读锁的过程，就叫做锁降级。在持有读锁变为持有写锁的过程中，其它线程都不能写，保证我写的数据能够被其它线程看到。如果不能同时持有读写锁那么就只能这么操作，获取写锁-写-释放写锁-获取读锁-其它线程读-释放读锁，在释放写锁和获取读锁之间就会存在空隙，有可能被其它线程进行写操作，导致它写的结果不能被其他线程获取。
所以，锁降级解决的就是即写即读的问题
5 锁降级示例
5.1 示例1
在释放写锁后，释放读锁前，其它线程可读，且中间其它线程都不可写
public class ReentrantLockTest5 { static ReentrantReadWriteLock lo = new ReentrantReadWriteLock(); static ReentrantReadWriteLock.ReadLock readLock = lo.readLock(); static ReentrantReadWriteLock.WriteLock writeLock = lo.writeLock(); public static void main(String[] args) { for (int i = 0;i < 10;i++) { new Thread(() -> write(), "write线程" + i).start(); } for (int i = 0;i < 10;i++) { new Thread(() -> read(), "read线程" + i).start(); } } private static void read() { readLock.lock(); System.out.println(Thread.currentThread().getName() + "开始读-----------"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "结束读-----------"); readLock.unlock(); } private static void write() { writeLock.lock(); System.out.println(Thread.currentThread().getName() + "开始写-----------"); try { Thread.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "结束写结束写-----------"); readLock.lock(); //锁降级 同时持有写锁和读锁 System.out.println(Thread.currentThread().getName() + "锁降级-----------"); System.out.println(Thread.currentThread().getName() + "释放写锁-----------"); writeLock.unlock(); //释放写锁，只持有读锁，此时其它线程可读 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //此时，它只拥有读锁 System.out.println(Thread.currentThread().getName() + "释放读锁-----------"); readLock.unlock(); // } }
执行结果，可以看到write8在释放了写锁后释放读锁前，其它线程进来读了
write线程1开始写----------- write线程1结束写结束写----------- write线程1锁降级----------- write线程1释放写锁----------- write线程1释放读锁----------- write线程0开始写----------- write线程0结束写结束写----------- write线程0锁降级----------- write线程0释放写锁----------- write线程0释放读锁----------- write线程2开始写----------- write线程2结束写结束写----------- write线程2锁降级----------- write线程2释放写锁----------- write线程2释放读锁----------- write线程3开始写----------- write线程3结束写结束写----------- write线程3锁降级----------- write线程3释放写锁----------- write线程3释放读锁----------- write线程4开始写----------- write线程4结束写结束写----------- write线程4锁降级----------- write线程4释放写锁----------- write线程4释放读锁----------- write线程5开始写----------- write线程5结束写结束写----------- write线程5锁降级----------- write线程5释放写锁----------- write线程5释放读锁----------- write线程7开始写----------- write线程7结束写结束写----------- write线程7锁降级----------- write线程7释放写锁----------- write线程7释放读锁----------- write线程6开始写----------- write线程6结束写结束写----------- write线程6锁降级----------- write线程6释放写锁----------- read线程1开始读----------- read线程1结束读----------- write线程6释放读锁----------- write线程9开始写----------- write线程9结束写结束写----------- write线程9锁降级----------- write线程9释放写锁----------- read线程0开始读----------- read线程0结束读----------- write线程9释放读锁----------- write线程8开始写----------- write线程8结束写结束写----------- write线程8锁降级----------- write线程8释放写锁----------- read线程7开始读----------- read线程3开始读----------- read线程5开始读----------- read线程4开始读----------- read线程8开始读----------- read线程9开始读----------- read线程2开始读----------- read线程6开始读----------- read线程9结束读----------- read线程7结束读----------- read线程3结束读----------- read线程4结束读----------- read线程6结束读----------- read线程2结束读----------- read线程8结束读----------- read线程5结束读----------- write线程8释放读锁----------- Process finished with exit code 0
5.2 示例2
在释放读锁前其它线程不可写
public class ReentrantLockTest4 { static ReentrantReadWriteLock lo = new ReentrantReadWriteLock(); static ReentrantReadWriteLock.ReadLock readLock = lo.readLock(); static ReentrantReadWriteLock.WriteLock writeLock = lo.writeLock(); public static void main(String[] args) { for (int i = 0;i < 10;i++) { new Thread(() -> write(), "write线程" + i).start(); } for (int i = 0;i < 10;i++) { new Thread(() -> read(), "read线程" + i).start(); } } private static void read() { readLock.lock(); System.out.println(Thread.currentThread().getName() + "开始读-----------"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "结束读-----------"); readLock.unlock(); } private static void write() { writeLock.lock(); System.out.println(Thread.currentThread().getName() + "开始写-----------"); try { Thread.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "结束写结束写-----------"); readLock.lock(); //锁降级 同时持有写锁和读锁 System.out.println(Thread.currentThread().getName() + "锁降级-----------"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "释放写锁-----------"); writeLock.unlock(); //释放写锁-此时值持有读锁 System.out.println(Thread.currentThread().getName() + "释放读锁-----------"); readLock.unlock(); //释放读锁 } }
执行结果
write线程1开始写----------- write线程1结束写结束写----------- write线程1锁降级----------- write线程1释放写锁----------- write线程1释放读锁----------- write线程2开始写----------- write线程2结束写结束写----------- write线程2锁降级----------- write线程2释放写锁----------- write线程2释放读锁----------- write线程0开始写----------- write线程0结束写结束写----------- write线程0锁降级----------- write线程0释放写锁----------- write线程0释放读锁----------- write线程3开始写----------- write线程3结束写结束写----------- write线程3锁降级----------- write线程3释放写锁----------- write线程3释放读锁----------- write线程4开始写----------- write线程4结束写结束写----------- write线程4锁降级----------- write线程4释放写锁----------- write线程4释放读锁----------- write线程7开始写----------- write线程7结束写结束写----------- write线程7锁降级----------- write线程7释放写锁----------- write线程7释放读锁----------- write线程8开始写----------- write线程8结束写结束写----------- write线程8锁降级----------- write线程8释放写锁----------- write线程8释放读锁----------- write线程5开始写----------- write线程5结束写结束写----------- write线程5锁降级----------- write线程5释放写锁----------- write线程5释放读锁----------- write线程6开始写----------- write线程6结束写结束写----------- write线程6锁降级----------- write线程6释放写锁----------- write线程6释放读锁----------- write线程9开始写----------- write线程9结束写结束写----------- write线程9锁降级----------- write线程9释放写锁----------- write线程9释放读锁----------- read线程0开始读----------- read线程1开始读----------- read线程2开始读----------- read线程3开始读----------- read线程4开始读----------- read线程5开始读----------- read线程6开始读----------- read线程7开始读----------- read线程8开始读----------- read线程9开始读----------- read线程4结束读----------- read线程1结束读----------- read线程0结束读----------- read线程2结束读----------- read线程5结束读----------- read线程3结束读----------- read线程6结束读----------- read线程9结束读----------- read线程7结束读----------- read线程8结束读-----------
5.3 再来个更清晰的例子
持有读写锁，释放写锁后释放读锁前，其它线程可读
public class ReentrantLockTest8 { static ReentrantReadWriteLock lo = new ReentrantReadWriteLock(); static ReentrantReadWriteLock.ReadLock readLock = lo.readLock(); static ReentrantReadWriteLock.WriteLock writeLock = lo.writeLock(); //读读共享 读写互斥 写写互斥 public static void main(String[] args) { CountDownLatch c = new CountDownLatch(10); new Thread(() ->write(c), "write线程" ).start(); for (int i = 0;i < 10;i++) { new Thread(() -> read(c), "read线程" + i).start(); } } private static void read(CountDownLatch c) { readLock.lock(); System.out.println(Thread.currentThread().getName() + "开始读-----------"); System.out.println(Thread.currentThread().getName() + "结束读-----------"); readLock.unlock(); c.countDown(); } private static void write(CountDownLatch c) { writeLock.lock(); System.out.println(Thread.currentThread().getName() + "写-----------"); readLock.lock(); //锁降级 同时持有写锁和读锁 System.out.println(Thread.currentThread().getName() + "释放写锁-----------"); writeLock.unlock(); //释放写锁，只持有读锁，此时其它线程可读 try { c.await(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "释放读锁-----------"); readLock.unlock(); //释放读锁 } }
执行结果，执行完成
write线程写----------- write线程释放写锁----------- read线程0开始读----------- read线程5开始读----------- read线程4开始读----------- read线程4结束读----------- read线程1开始读----------- read线程1结束读----------- read线程7开始读----------- read线程7结束读----------- read线程6开始读----------- read线程5结束读----------- read线程3开始读----------- read线程9开始读----------- read线程9结束读----------- read线程2开始读----------- read线程0结束读----------- read线程2结束读----------- read线程3结束读----------- read线程6结束读----------- read线程8开始读----------- read线程8结束读----------- write线程释放读锁----------- Process finished with exit code 0
持有读写锁，释放读锁和写锁前，其它线程不可读
把try { c.await(); } catch (InterruptedException e) { e.printStackTrace(); }放到释放写锁前
public class ReentrantLockTest7 { static ReentrantReadWriteLock lo = new ReentrantReadWriteLock(); static ReentrantReadWriteLock.ReadLock readLock = lo.readLock(); static ReentrantReadWriteLock.WriteLock writeLock = lo.writeLock(); //读读共享 读写互斥 写写互斥 public static void main(String[] args) { CountDownLatch c = new CountDownLatch(10); new Thread(() ->write(c), "write线程" ).start(); for (int i = 0;i < 10;i++) { new Thread(() -> read(c), "read线程" + i).start(); } } private static void read(CountDownLatch c) { readLock.lock(); System.out.println(Thread.currentThread().getName() + "开始读-----------"); System.out.println(Thread.currentThread().getName() + "结束读-----------"); readLock.unlock(); c.countDown(); } private static void write(CountDownLatch c) { writeLock.lock(); System.out.println(Thread.currentThread().getName() + "写-----------"); readLock.lock(); //锁降级 同时持有写锁和读锁 try { c.await(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "释放写锁-----------"); writeLock.unlock(); //释放写锁，只持有读锁，此时其它线程可读 System.out.println(Thread.currentThread().getName() + "释放读锁-----------"); readLock.unlock(); //释放读锁 } }
执行结果，卡住了，没有执行完
