【Java总结】ReadWriteLock读写锁初探

上一篇我们说到了一些锁的名称特性, 问题等 如Synchronized存在明显的一个性能问题就是读与读之间互斥简言之就是，我们编程想要实现的最好效果是，可以做到读和读互不影响，读和写互斥，写和写互斥，提高读写的效率，如何实现呢？

首先我们看下涉及到读写锁的一个接口

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing
     */
    Lock writeLock();
}

ReadWriteLock中有一组锁，一个是读锁，一个是写锁。

那么正式介绍本文的主角，ReentrantReadWriteLock继承了ReadWriteLock，并且实现了可重入性

我们看下其构造方法

    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * default (nonfair) ordering properties.
     */
    public ReentrantReadWriteLock() {
        this(false);
    }

    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * the given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     * 是否使用公平锁策略
     */
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

公平性

• 非公平策略
  当以非公平初始化时，读锁和写锁的获取的顺序是不确定的。非公平锁主张竞争获取，可能会延缓一个或多个读或写线程，但是会比公平锁有更高的吞吐量。
• 公平策略
  当以公平模式初始化时，线程将会以队列的顺序获取锁。当当前线程释放锁后，等待时间最长的写锁线程就会被分配写锁；或者有一组读线程组等待时间比写线程长，那么这组读线程组将会被分配读锁。

可重入性

默认是可重入的但是要成对的获取锁和释放锁,如下的这段例子，主线程两次获取锁lock.writeLock().lock()，说明其实可重入的，但是输出结果是只有realse one once；因此thread1执行的时候尝试获取锁此时因为主线程未释放，也就导致了死锁。

public static void main(String[] args) throws InterruptedException {
        final ReentrantReadWriteLock  lock = new ReentrantReadWriteLock ();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                lock.writeLock().lock();
                System.out.println("Thread real execute");
                lock.writeLock().unlock();
            }
        });

        lock.writeLock().lock();
        lock.writeLock().lock();
        thread1.start();
        Thread.sleep(200);
        
        System.out.println("realse one once");
        lock.writeLock().unlock();
    }

升级和降级

看过我前面几篇线程并发的文章的同学们应该比较清楚，synchronized关键字在jdk1.5以后有根据竞争的强度，来依次升级为偏向锁-轻量级锁-重量级锁；这当然是jdk层面的一个实现。
我们在看一下我们今天说到的主角ReentrantReadWriteLock的升级和降级

写入锁可以降级为读锁吗？读锁是否可以升级为写锁，优先于其他等待的读取或写入操作？简言之就是说，锁降级：从写锁变成读锁；锁升级：从读锁变成写锁

测试锁升级

  public static void main(String[] args) {
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        lock.readLock().lock();
        System.out.println("getReadLockSuccess");
        lock.writeLock().lock();
        System.out.println("getWriteLockSuccess");
    }

上面的测试代码会产生死锁，因为同一个线程中，在没有释放读锁的情况下，就去申请写锁，这属于锁升级，ReentrantReadWriteLock是不支持的。

测试锁降级

 public static void main(String[] args) {
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();  
        lock.writeLock().lock();  
        System.out.println("getWriteLockSuccess");  
          
        lock.readLock().lock();  
        System.out.println("getReadLockSuccess");  
    }

ReentrantReadWriteLock支持锁降级，上面代码不会产生死锁。这段代码虽然不会导致死锁，但没有正确的释放锁。从写锁降级成读锁，并不会自动释放当前线程获取的写锁，仍然需要显示的释放，否则别的线程永远也获取不到写锁。

读写锁互斥关系

ReetrantReadWriteLock读写锁的实现中，读锁使用共享模式；写锁使用独占模式，换句话说，读锁可以在没有写锁的时候被多个线程同时持有，写锁是独占的。
ReetrantReadWriteLock读写锁的实现中，需要注意的，当已获取读锁时，写锁就不能获得；而当有写锁时，除了获得写锁的这个线程可以获得读锁外，其他线程不能获得读锁