读写锁

本片主要介绍java并发包中的读写锁java.util.concurrent.locks.ReentrantReadWriteLock

传统的锁的劣势

在有些场景中，当有几个线程，其中绝大多数的线程都是对临界区进行读操作，并且读操作不会对临界区的完整性产生破坏，不会修改临界区，此时这些读操作就没有必要还是实行串行的获取锁，读取数据，释放锁 的操作，这样严重影响了效率。

读写锁的优势

读写分离锁可以有效的降低锁竞争，例如线程a，b，c是进行读操作，线程d，e进行写操作，这时如果使用普通的锁，那么线程a，b,c之间是串行操作的，即必须一个一个的挨着来读取数据，但是明明它们一起工作也不会有问题，这就造成了不必要的锁竞争。如果采用读写锁，那么a,b,c之间是可以一起进入临界区进行数据的读取的，仅仅当读写操作，写写操作的时候才会产生一个线程等待另一个线程释放锁的情况发生

例子

public class ReadWriteLock {

    private static Random random = new Random();
    private static Integer value;

    public static void read(Lock lock) throws InterruptedException {
        try {
            lock.lock();
            System.out.println("read value="+value);
            Thread.sleep(1000);
        } finally {
            lock.unlock();
        }
    }

    public static void write(Lock lock) throws InterruptedException{
        try {
            lock.lock();
            value = random.nextInt(100);
            System.out.println("value="+value);
            Thread.sleep(1000);
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final ReentrantLock lock =  new ReentrantLock();
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        final ReadLock readLock = readWriteLock.readLock();
        final WriteLock writeLock = readWriteLock.writeLock();


        Runnable readRunnable = new Runnable() {

            @Override
            public void run() {
                try {
//                  read(lock);
                    read(readLock);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Runnable writeRunnable = new Runnable() {

            @Override
            public void run() {
                try {
//                  write(lock);
                    write(writeLock);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };


        for(int i = 18;i<20;i++){
            new Thread(writeRunnable).start();
        }

        for(int i = 0;i<18;i++){
            new Thread(readRunnable).start();
        }       
    }
}

分析，在本程序中分别采用了普通锁（注释的部分放开）和读写锁模拟了对临界区资源读取的过程，发现当采用普通锁的时候，整个程序运行了20多秒，隔一会儿打印一下value（读取），但是采用读写锁后，整个程序只执行了2到3秒，打印（读取）几乎是同时完成的

读写锁的适用场景

读操作次数远远大于写操作次数，那么读写锁就可以发挥最大的功能，提升系统的性能