Java多线程/并发06、线程锁Lock与ReadWriteLock

java的基本锁类型，都以接口形式出现，常用的有以下两种锁的接口：

• Lock锁。它的实现有ReentrantLock, ReentrantReadWriteLock.ReadLock,
  ReentrantReadWriteLock.WriteLock
• ReadWriteLock锁。它的实现有ReentrantReadWriteLock。

一、lock简单使用方法

1、Lock锁基本都是排他锁，它和synchronized很类似，都能对一块代码进行上锁，从而使得同一时间内只有一个线程能访问。那么有什么差别呢？
Lock 和 synchronized 有一点明显的区别 —— lock 必须在 finally 块中释放。否则，如果受保护的代码将抛出异常，锁就有可能永远得不到释放！这一点区别极为重要。忘记在 finally 块中释放锁，可能会在程序中留下一个定时炸弹，当有一天炸弹爆炸时，您要花费很大力气才有找到源头在哪。而使用同步，JVM 将确保锁会获得自动释放。除此之外，当许多线程都在争用同一个锁时，使用 ReentrantLock 的总体开支却比 synchronized 少很多。
还记得《synchronized同步 》例子吗，我们用lock改写一下：

class Pan1 {
    private Lock lock = new ReentrantLock(); 
    /*烹饪方法，该方法输出步骤*/
    public void Cook(String[] steps) {
         lock.lock();
         try{
            for (int i = 0; i < steps.length; i++) {
                /*模拟竞争造成的线程等待，这样效果明显些*/
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.print(steps[i]);
            }
            System.out.println("");
         }finally{
             /*
             * synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，
             * 而且在代码执行出现异常时，JVM会自动释放锁定。
             * 但是使用Lock则不行，lock是通过代码实现的。
             * 要保证锁定一定会被释放，就必须将unLock()放到finally{}中
             */
            lock.unlock();
         }

    }
    /*青椒炒肉制作步骤：a1.放肉，a2.放盐，a3.放辣椒  a4 a5....*/
    String[] steps_LaJiaoChaoRou={"a1.","a2.","a3.","a4.","a5.","a6.","a7.","a8.","a9.","a10.","OK：辣椒炒肉"};
    /*番茄炒蛋制作步骤：b1.放蛋，b2.放盐，b3.放番茄*/
    String[] steps_FanQieChaoDan={"b1.","b2.","b3.","b4.","b5.","b6.","OK:番茄炒蛋"};
}

public class LockDemo {
    public static void main(String[] args) {

        final Pan pan=new Pan();
        /*线程1：老大炒青椒炒肉。*/
        new Thread(){
            public void run() {
                /*为了看出错乱效果，这里用死循环，一段时间后手工点击停止运行按钮*/
                while (true) {
                    try {
                        /*青椒炒肉需要5秒;*/
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    pan.Cook(pan.steps_LaJiaoChaoRou);
                }
            }
        }.start();

        /*线程2：老二炒番茄炒蛋。*/
        new Thread(){
            public void run() {
                /*为了看出错乱效果，这里用死循环，一段时间后手工点击停止运行按钮*/
                while (true) {
                    try {
                        /*番茄炒蛋需要5秒;*/
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    pan.Cook(pan.steps_FanQieChaoDan);
                }
            }
        }.start();
    }
}

有人总结了lock和synchronized同步的区别:
1. lock是一个接口，而synchronized是java的一个关键字，synchronized是内置的语言实现；（具体实现上的区别在《Java虚拟机》中有讲解底层的CAS不同，以前有读过现在又遗忘了。）
2. synchronized在发生异常时候会自动释放占有的锁，因此不会出现死锁；而lock发生异常时候，不会主动释放占有的锁，必须手动unlock来释放锁，可能引起死锁的发生。（所以最好将同步代码块用try catch包起来，finally中写入unlock，避免死锁的发生。）
3. lock等待锁过程中可以用interrupt来终端等待，而synchronized只能等待锁的释放，不能响应中断；
4. lock可以通过trylock来知道有没有获取锁，而synchronized不能；
5. Lock可以提高多个线程进行读操作的效率。（可以通过readwritelock实现读写分离）

二、ReadWriteLock读写锁

ReadWriteLock包含两部分：读锁、写锁。上读锁时，代码块中数据对其它线程来说可读不可写；上写锁时，代码块中的数据对其它线程来说不可写也不可读。由于实现了读写分离，在读比写多的场景下，这无疑更高效。
API中的例子很经典：

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) {
                    System.out.println(Thread.currentThread().getName()
                            + ": 缓存未初始化");
                    data = getData();
                    cacheValid = true;
                    System.out.println(Thread.currentThread().getName()
                            + ": 缓存初始完成，当前值：" + data);
                }
                /* 降级锁：在释放写锁前获取读锁 */
                rwl.readLock().lock();
            } finally {
                rwl.writeLock().unlock(); /* 释放写锁，依然保持读锁 */
            }
        }
        /* 此时，依然存在读锁 */
        try {
            System.out.println(Thread.currentThread().getName() + ": 获取缓存值为："+ data);
        } finally {
            /* 释放读锁 */
            rwl.readLock().unlock();
        }
    }
    int getData(){
        return new Random().nextInt(100000);
    }
}

public class LockDemo {
    public static void main(String[] args) {
        final CachedData cachedData = new CachedData();
        for (int i = 0; i < 5; i++) {
            new Thread() {
                public void run() {
                    cachedData.processCachedData();
                }
            }.start();
        }
    }
}

输出：

Thread-0: 缓存未初始化
Thread-0: 缓存未初始完成，当前值：27269
Thread-0: 获取缓存值为：27269
Thread-1: 获取缓存值为：27269
Thread-3: 获取缓存值为：27269
Thread-2: 获取缓存值为：27269
Thread-4: 获取缓存值为：27269

我们把锁去掉，看看会输出什么
改写CachedData类:

class CachedData {
    Object data;
    volatile boolean cacheValid;
    final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    void processCachedData() {
        /* 初始化变量，需要写入数据 */
        if (!cacheValid) {
            System.out.println(Thread.currentThread().getName()
                    + ": 缓存未初始化");
            data = getData();
            cacheValid = true;
            System.out.println(Thread.currentThread().getName()
                    + ": 缓存初始完成，当前值：" + data);
        }

        System.out.println(Thread.currentThread().getName() + ": 获取缓存值为："
                + data);
    }
    int getData(){
        return new Random().nextInt(100000);
    }
}

输出：

Thread-0: 缓存未初始化
Thread-1: 缓存未初始化
Thread-2: 缓存未初始化
Thread-0: 缓存初始完成，当前值：41131
Thread-0: 获取缓存值为：41131
Thread-2: 缓存初始完成，当前值：41131
Thread-2: 获取缓存值为：41131
Thread-1: 缓存初始完成，当前值：11655
Thread-1: 获取缓存值为：11655
Thread-3: 获取缓存值为：11655
Thread-4: 获取缓存值为：11655

乱套了，一开始3个线程同时都去写缓存了，然后获取缓存也各不相同。

总结：

在运用读写锁时，注意锁的降级：
写锁是可以获得读锁的，即:

rwl.writeLock().lock();
//在写锁状态中，可以获取读锁
rwl.readLock().lock();
rwl.writeLock().unlock();

读锁是不能够获得写锁的，如果要加写锁，本线程必须释放所持有的读锁，即:

rwl.readLock().lock();
//......
//必须释放掉读锁，才能够加写锁
rwl.readLock().unlock();
rwl.writeLock().lock();