读锁应该插队吗？什么是锁的升降级？

背景

ReentrantReadWriteLock可以设置公平或非公平，为什么？

读锁插队策略

每次获取响应锁之前都要检查能否获取

• readerShouldBlock
• writerShouldBlock

公平锁

final boolean writerShouldBlock() { return hasQueuedPredecessors();}final boolean readerShouldBlock() { return hasQueuedPredecessors();}

由此可见只要等待队列中有线程等待，也就是hasQueuedPredecessors返回true时，writer和reader都会block，乖乖排队

非公平锁

final boolean writerShouldBlock() { return false; // writers can always barge}final boolean readerShouldBlock() { return apparentlyFirstQueuedIsExclusive();}final boolean apparentlyFirstQueuedIsExclusive() { Node h, s; return (h = head) != null && (s = h.next) != null && !s.isShared() && s.thread != null;}

• 写锁始终是false，由此可见想要获取写锁随时可以插队
• 读锁

T1,T2正在持有读锁，T3请求写锁，于是进入等待，这时候T4插队获取读锁，允许T4插队还是不插队呢？

1.允许

少量线程插队确实可以提升效率，但是：

问题：如果读取线程不断增加，线程5,6,7,8,9都来请求，读锁长时间不释放，线程3进入饥饿状态，我写操作还执不执行了？

2.不允许

都有机会运行，都不会等待太久时间

import java.util.concurrent.locks.ReentrantReadWriteLock;class ReadLockJumpQueue { private static final ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock(); private static final ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock(); private static final ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock(); private static void read() { readLock.lock(); try { System.out.println(Thread.currentThread().getName() + "得到读锁，正在读"); Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println(Thread.currentThread().getName() + "释放读锁"); readLock.unlock(); } } private static void write() { writeLock.lock(); try { System.out.println(Thread.currentThread().getName() + "得到写锁，正在写"); Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println(Thread.currentThread().getName() + "释放写锁"); writeLock.unlock(); } } public static void main(String[] args) throws InterruptedException { new Thread(() -> read(), "Thread-2").start(); new Thread(() -> read(), "Thread-4").start(); new Thread(() -> write(), "Thread-3").start(); new Thread(() -> read(), "Thread-5").start(); }}

锁的升降级

读写锁的降级

import java.util.concurrent.locks.ReentrantReadWriteLock;public class CachedData { Object data; volatile boolean cacheValid; final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); void processCachedData() { //首先获取读锁 rwl.readLock().lock(); //判断缓存是否有效，有效直接输出 if (!cacheValid) { //无效就把读锁释放，上写锁 //这个时候有可能有其他线程抢先获取了写锁 rwl.readLock().unlock(); rwl.writeLock().lock(); try { //如果缓存还是无效 if (!cacheValid) { //更新data，缓存设为有效 data = new Object(); cacheValid = true; } //因为我们想要在后续打印出data，所以请求读锁 rwl.readLock().lock(); } finally { //确保写锁释放，整个时候就是读锁了，然后打印data rwl.writeLock().unlock(); } } try { System.out.println(data); } finally { //确保读锁能释放 rwl.readLock().unlock(); } }}

为什么需要锁降级？

如果我们一直使用写锁最后释放写锁，虽然线程安全，但是没必要，因为我们只有一处修改数据的代码：

后面data只是读，这个时候还用写锁就不能多个线程读了，持有写锁浪费资源，降低效率，这个时候就用锁的降级提高整体效率

ReentrantReadWriteLock支持锁降级，不支持锁升级

import java.util.concurrent.locks.ReentrantReadWriteLock;public class CachedData { final static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); public static void main(String[] args) { upgrade(); } public static void upgrade() { //获取读锁 rwl.readLock().lock(); //获取写锁，发生阻塞 rwl.writeLock().lock(); //不会打印 System.out.println("成功升级"); }}rwl.writeLock().lock();rwl.readLock().lock();rwl.readLock().unlock();System.out.println("成功降级");

由此可见ReentrantReadWriteLock支持锁降级，不支持锁升级

为什么不支持？

写锁，只能有一个线程持有，并且不可能存在读锁和写锁同时持有的情况

不然A升级,B升级，大家一起升级，但是写锁只有一个，给谁？

那只能这样，比如A,B,C都持有读锁，A尝试升级到写锁，那么B,C就必须释放读锁，这个时候A可以升级为写锁

那如果A,B都想升级为写锁，A等待其他线程释放，B等待其他线程释放，A等B，B等A，死锁

实现方案

保证每次只有一个线程升级那么线程是安全的，只不过最常见的ReentrantReadWriteLock不支持