浅谈ReadWriteLock

1.什么是读写锁？为什么使用读写锁，优势在哪里？

在并发的情况下，如果多个线程同时读一个资源类是没有任何问题的；但是，多个线程同时去写入或者修改一个资源类就会存在问题。如果使用非读写锁，理论上所有读之间、读与写之间、写和写之间都是串行操作，这样会使代码运行效率大打折扣。
读写锁的意义在于同一时刻可以允许多个多线程去读，但是在任何一个写线程访问的时候，所有的读线程和其他写线程都会被阻塞。读写锁实际维护了一对锁，一个读锁，一个写锁，通过分离读锁和写锁，来提升代码运行效率。

写锁是排他锁，如果当前线程已经获得了写锁则增加写状态，如果当前线程在获取写锁时，读锁已经被获取或者该线程不是已经获得写锁的线程则进入等待。

读锁是可重入共享锁，能够被多个线程同时获取，在没有其他写线程访问时，读锁总会被成功获取。如果当前线程已经获取了读锁，则增加读状态。如果当前线程在获取读锁时，写锁已被其他线程获取则进入等待。

import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class TestRWlock {

    private static Lock lock = new ReentrantLock();

    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private static Lock readLock = readWriteLock.readLock();
    private static Lock writeLock = readWriteLock.writeLock();

    public static void main(String[] args) throws InterruptedException {
        test(); //ReadWriteLock
        test1(); //Lock 
    }

    public static void test1() throws InterruptedException {
        CountDownLatch downLatch = new CountDownLatch(13);
        Long startTime = new Date().getTime();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    lock.lock();
                    TimeUnit.SECONDS.sleep(1);
                    lock.unlock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    downLatch.countDown();
                }
            }).start();
        }

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try {
                    lock.lock();
                    TimeUnit.SECONDS.sleep(1);
                    lock.unlock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    downLatch.countDown();
                }

            }).start();
        }
        downLatch.await();
        Long result = TimeUnit.SECONDS.convert(new Date().getTime() - startTime, TimeUnit.MILLISECONDS);
        System.out.println("用时" + result + "秒");

    }

    public static void test() throws InterruptedException {
        CountDownLatch downLatch = new CountDownLatch(13);
        Long startTime = new Date().getTime();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                readLock.lock();
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    readLock.unlock();
                    downLatch.countDown();
                }
            }).start();
        }

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                writeLock.lock();
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    writeLock.unlock();
                    downLatch.countDown();
                }
            }).start();
        }
        downLatch.await();
        Long result = TimeUnit.SECONDS.convert(new Date().getTime() - startTime, TimeUnit.MILLISECONDS);
        System.out.println("用时" + result + "秒");

    }
}

通过运行结果来看，使用ReadWriteLock的效率要明显高于Lock 。
特别是业务场景中读操作的次数大于写操作的次数，使用读写锁就可以发挥最大的功效

2.读写锁的降级

锁降级指当前线程把持住写锁再获取到读锁，随后释放先前拥有的写锁的过程。

如果只使用写锁，那么释放写锁之后，其他线程就会获取到写锁或读锁，使用锁降级可以在释放写锁前获取读锁，这样其他的线程就只能获取读锁，对这个数据进行读取，但是不能获取写锁进行修改，只有当前线程释放了读锁之后才可以进行修改。相对于一直使用写锁，锁降级可以减少其他读线程的阻塞。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class rwlock {

    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private static Lock readLock = readWriteLock.readLock();
    private static Lock writeLock = readWriteLock.writeLock();


    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    testRW();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }
    }

    public static void testRW() throws InterruptedException {
        writeLock.lock();
        System.out.println(Thread.currentThread().getName() + "进入写锁");
        readLock.lock();
        System.out.println(Thread.currentThread().getName() + "进入读锁");
        writeLock.unlock();
        System.out.println(Thread.currentThread().getName() + "释放写锁");
        readLock.unlock();
        System.out.println(Thread.currentThread().getName() + "释放读锁");
    }

}

通过运行结果可看出每一拥有写锁的线程在释放写锁之前都拿到了读锁。