读书笔记：Java并发实战 第13章 显式锁

1、一般用法

<pre name="code" class="java">	Lock lock = new ReentrantLock();

public void method(){
lock.lock();
try{
//...
}finally{
lock.unlock();
}
}

特点：

1、加锁和解锁的方法都是显式的

2、在调用lock()方法时，和进入同步代码块有相同的内存语义

3、在调用unlock()方法时，和退出同步代码块有相同的内存语义

4、独占和可重入

2、轮询锁

先看由于动态的参数顺序造成死锁的例子：

资源类：MyLock

public class MyLock {

public Lock lock = new ReentrantLock();

public String name;

public MyLock(String name){
this.name = name;
}

}

任务类：Executor

public class Executor {

public void work(MyLock a,MyLock b){
String threadName = Thread.currentThread().getName();
a.lock.lock();
System.out.println(threadName+"获得"+a.name+"的锁");
try{
TimeUnit.SECONDS.sleep(1);
System.out.println(threadName+"请求"+b.name+"的锁");
b.lock.lock();
}catch(Exception e){
//...
}finally{
b.lock.unlock();
a.lock.unlock();
}
}

}

测试类：

MyLock x = new MyLock("锁X");
MyLock y = new MyLock("锁y");
Executor exec = new Executor();
ThreadA a = new ThreadA("线程A",x,y,exec);
ThreadB b = new ThreadB("线程B",x,y,exec);
a.start();
b.start();

这段程序运行的结果就会造成死锁，下面，将Executor的work()方法改用轮询锁来解决死锁问题

轮询锁是通过tryLock()方法来实现的，这个方法尝试获取一个锁，如果获取到，返回true，否则返回false，这种立即返回的方式，避免了无效的等待。当嵌套调用锁时，如果里层的tryLock()方法返回false，就释放外层的锁，以便让其他线程获得所有的锁

使用轮询锁需要注意的一个重点是：各线程不要使用相同时间间隔来轮询锁，否则很容易发生活锁，如下面的例子

while(true){
String threadName = Thread.currentThread().getName();
if(a.lock.tryLock()){
System.out.println(threadName+"获得"+a.name+"的锁");
try{
TimeUnit.SECONDS.sleep(1);
System.out.println(threadName+"请求"+b.name+"的锁");
if(b.lock.tryLock()){
try{
System.out.println(threadName+"获得"+b.name+"的锁");
return;
}catch(Exception e){
//...
}finally{
b.lock.unlock();
}

}
}catch(Exception e){
//...
}finally{
a.lock.unlock();
}
}
}

发生活锁的原因是：

线程A得到锁X请求锁Y，线程B得到锁Y请求锁X，此时两个线程都不得到内层锁而放弃外层锁，然后又立即做相同的步骤，这样，活锁就发生了

我们只需要在每次释放外层锁之后，轮询之前等待一个随机时间，就能很大程度避免发生活锁

3、定时锁

在使用tryLock()方法时，可以加入参数，指定超时时间，在这个时间内如果等待不到锁，则会返回false

4、可中断锁

在等待获取内置锁的情况下是不能响应中断的，这让实现可取消的任务变得复杂。

Lock实现了可中断锁，能够响应中断：lock.lockInterruptibli();——获取一个可响应中断的锁

5、公平锁和非公平锁

ReentrantLock的构造函数中提供了公平锁（默认）和非公平锁的选择

公平锁：所有请求锁的线程在队列中等待锁，线程获得锁的顺序按先来先得的原则

非公平锁：当线程请求的锁不能得到时，就在队列中等待，如果线程请求锁时，该锁刚好被释放，那么该线程可以得到这个锁

一般情况下，非公平锁的性能要高于公平锁。因为公平性会造成较多的线程挂起和恢复操作，在恢复一个被挂起的线程与该线程真正运行之间存在严重的延迟，比如：在高并发的情况下，当线程A是否一个锁时，因等待锁而被挂起的线程B会被唤醒，在B被完全唤醒之前，其他线程可能已经完成了"获得-释放"该锁的动作，而并没有影响B获得锁的时刻，如果采用公平锁，其他线程无法请求这个锁，吞吐率就降低了

因此：如果线程持有锁的时间很短，应该尽量使用非公平锁

6、读写锁

互斥锁是最保守的加锁策略，在很多情况下并不需要如此严格的加锁方式，并发的读操作如果使用互斥锁是不必要的，而且会降低读的性能，我们只要保证不会读取到脏数据即可，即：读取数据时不允许写，但允许读。读写锁可以实现这个功能，看下面的例子：

private ReadWriteLock lock = new ReentrantReadWriteLock();
private Lock readLock = lock.readLock();
private Lock writeLock = lock.writeLock();

public void read(){

readLock.lock();

try {
//...
} catch (Exception e) {

}finally{
readLock.unlock();
}
}

public void write(){

writeLock.lock();

try {
//...
} catch (Exception e) {

}finally{
writeLock.unlock();
}
}

线程A持有读锁，线程B请求读锁，线程B可以立即获得读锁

线程A持有读锁，线程B请求写锁：线程B需要在线程A释放读锁后才能获得写锁

线程A持有写锁，线程B请求读锁：线程B需要在线程A释放写锁后才能获得读锁

线程A持有写锁，线程B请求写锁：线程B需要在线程A释放写锁后才能获得写锁

读、写锁之间可以定义不同的交互方式，包括：

1、当释放写锁时，读线程和写线程哪个优先得到锁

2、当释放读锁时，并且队列中有写线程正在等待，此时是否允许读线程插队

3、读、写锁是否允许重入

4、锁降级：线程将持有的写锁在不释放锁的情况下转变为读锁

5、锁升级：线程将持有的读锁在不释放锁的情况下转变为写锁

ReentrantReadWriteLock的公平锁情况下：如果一个线程持有读锁，当等待线程中有请求写锁时，优先于等待的读锁；锁降级是允许的，但锁升级不允许，这样会导致死锁，因为写锁是互斥的，获得写锁要等待所有其他线程释放读写锁，如果两个线程同时升级锁，那么会同时在等待对方释放锁

读写锁的性能

在读操作较多的情况下，读写锁能提高性能，其他情况下要比独占锁的性能差，因为它的实现比较复杂

总结：

Lock提供一种灵活的加锁机制，在很多场合，是不适合使用同步代码块的，同步代码块的缺点和优点集于一身：锁的获取和释放是在同一个代码块中的，好处是我们不必考虑代码块中遇到异常退出时需要如何释放锁，缺点是无法实现连锁式加锁

连锁式加锁是指：在锁分段的应用场景下，比如ConcurrentHashMap，它把散列桶分成不同的段，每个段使用一个独立的锁，当我们需要遍历时，需要持有某个段的锁，直到获得下一个段的锁才释放原有的锁，这种情况下，内置锁是无法完成的

关于synchronized和ReentrantLock的选择

在Java 5.0时代，ReentrantLock的性能比内置锁有更好的竞争性能，而Java 6之后改进了内置锁，二者性能相差无几

由于ReentrantLock存在更高的活跃性危险，因此一般情况下优先使用synchronized，只有需要使用ReentrantLock的特殊功能是才考虑ReentrantLock

并且，在后面的Java版本中可能会提升synchronized而不是ReentrantLock的性能，因为synchronized是JVM的内置属性，可以执行一些优化