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

本文主要是介绍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();

这篇关于Java多线程/并发06、线程锁Lock与ReadWriteLock的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---