java并发排它锁_Java并发——显示锁

Java提供一系列的显示锁类，均位于java.util.concurrent.locks包中。

锁的分类： 排他锁，共享锁

排他锁又被称为独占锁，即读写互斥、写写互斥、读读互斥。

Java的ReadWriteLock是一种共享锁，提供读读共享，但读写和写写仍然互斥。

Lock接口

Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也应该是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。

public interfaceLock {voidlock();void lockInterruptibly() throwsInterruptedException;booleantryLock();boolean tryLock(long time, TimeUnit unit) throwsInterruptedException;voidunlock();

Condition newCondition();

}

Lock API详解

void lock();

获取锁。如果锁不可用，出于线程调度目的，将禁用当前线程，并且在获得锁之前，该线程将一直处于休眠状态。

void lockInterruptibly() throws InterruptedException;

如果当前线程未被中断，则获取锁。

如果锁可用，则获取锁，并立即返回。

如果锁不可用，出于线程调度目的，将禁用当前线程，并且在发生以下两种情况之一以前，该线程将一直处于休眠状态：

锁由当前线程获得；

其他某个线程中断当前线程，并且支持对锁获取的中断。

如果当前线程在下列情况会抛出 InterruptedException，并清除当前线程的已中断状态：

在进入此方法时已经设置了该线程的中断状态；

在获取锁时被中断，并且支持对锁获取的中断。

Condition newCondition();

返回绑定到此 Lock 实例的新 Condition 实例。

boolean tryLock();

仅在调用时锁为空闲状态才获取该锁。通常对于那些不是必须获取锁的操作可能有用。

若锁可用，则获取锁，并立即返回值 true。

若锁不可用，则此方法将立即返回值 false。

boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

若锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁。

1.如果锁可用，则此方法将立即返回值 true。

2.如果锁不可用，出于线程调度目的，将禁用当前线程，并且在发生以下三种情况之一前，该线程将一直处于休眠状态：

锁由当前线程获得；

其他某个线程中断当前线程，并且支持对锁获取的中断；

已超过指定的等待时间

3.如果获得了锁，则返回值 true。

4.如果当前线程：

在进入此方法时已经设置了该线程的中断状态；或者

在获取锁时被中断，并且支持对锁获取的中断，则将抛出 InterruptedException，并会清除当前线程的已中断状态。

5.如果超过了指定的等待时间，则将返回值 false。如果 time 小于等于 0，该方法将完全不等待。

void unlock();

释放锁。对应于lock()、tryLock()、tryLock(xx)、lockInterruptibly()等操作，如果成功的话应该对应着一个unlock()，这样可以避免死锁或者资源浪费。

Lock的使用

Lock的lock()方法保证了只有一个线程能够执有此锁。对于任何一个lock()方法，都需要一个unlock()方法与之对应，通常情况下为了保证unlock()方法总是能够执行，unlock()方法被置于finally中。

Lock的标准适用方法如下，等价于synchronized代码块：

lock.lock();

try{

//...需要保证线程安全的代码。

} finally{

lock.unlock();

}

ReentrantLock

Reentrant英文意思为重入。ReentrantLock即重入锁。

ReentrantLock提供了与synchronized相同的互斥和内存可见性的保证。获得ReentrantLock的锁与进入synchronized块有着相同的内存语义，释放ReentrantLock锁与退出synchronized块有相同的内存语义。

那么为什么要创建与synchronized如此相似的东西呢？原因是synchronized在大部分情况下能够很好的工作，但是有些功能上存在着局限：

内部锁不能中断那些正在等待获取锁的进程，并且在请求锁失败的情况下，线程必须无限等待；

内部锁必须在获取它们的代码块中被释放；这很好的简化了代码，但是在某些情况下，一个更灵活的加锁机制提供了更好的活跃度和性能。

反之ReentrantLock拥有如下优点：

ReentrantLock可以轮询和可定时的锁请求。lock.tryLock()

ReentrantLock可中断的锁获取操作。lock.lockInterruptibly()

jdk6之前，ReentrantLock性能优于synchronized。JDK6开始，两者性能差不多。

相对于synchronized来说，synchronized的锁的获取是释放必须在一个模块里，获取和释放的顺序必须相反，而Lock则可以在不同范围内获取释放，并且顺序无关。

ReentrantLock的特性

可重入

synchronized和ReentrantLock均有可重入性。

在使用synchronized时，一个线程请求得到一个对象锁后再次请求此对象锁，可以再次得到该对象锁。即当一个线程已经进入到synchronized方法/块中时，可以进入到本类的其他synchronized方法/块中。

对于ReentrantLock，单线程可以重复获取锁，同时一定要重复释放。

例：两次获取锁，则必须两次解锁。

ReentrantLock lock = newReentrantLock();

lock.lock();

lock.lock();try{//...

}finally{

lock.unlock();

lock.unlock();

}

可中断

ReentrantLock.lockInterruptibly() 该方法与lock()方法类似，但该方法用于可中断的加锁。

在lockInterruptibly() 锁定的代码中，一旦接收到中断通知，就会抛出InterruptedException异常。

所以在被锁定的代码中ReentrantLock可以响应其他线程发起的中断通知。而被synchronized加锁的代码中，无法获取中断通知。

可限时

超时不能获得锁，就返回false，不会永久等待构成死锁。

ReentrantLock.tryLock()方法用于尝试锁定。参数为等待时间。该方法返回boolean值。若锁定成功，则返回true。锁定失败，则返回false。

公平锁

公平锁不会产生线程饥饿，锁被线程先来先得。ReentrantLock内部需要维护一个线程队列，性能稍高，如无必要，没必要使用。

public ReentrantLock(boolean fair) 是一个构造方法，fair默认为false，当设置为true时，及表示当前构造的锁是公平锁。

例：创建一个公平锁。

public static ReentrantLock fairLock = new ReentrantLock(true);

《Java并发编程实践》中说明：当需要可定时的、可轮询的与可中断的锁获取操作，公平队列，或者非块结构的锁，建议使用ReentrantLock。否则，请使用synchronized。

例：使用Lock定义一个类似于AtomicInteger的原子操作的整数类。

public classAtomicIntegerWithLock {private intvalue;private Lock lock = newReentrantLock();publicAtomicIntegerWithLock() {super();

}public AtomicIntegerWithLock(intvalue) {this.value =value;

}public final intget() {

lock.lock();try{returnvalue;

}finally{

lock.unlock();

}

}public final void set(intnewValue) {

lock.lock();try{

value=newValue;

}finally{

lock.unlock();

}

}public final int getAndSet(intnewValue) {

lock.lock();try{int ret =value;

value=newValue;returnret;

}finally{

lock.unlock();

}

}public final boolean compareAndSet(int expect, intupdate) {

lock.lock();try{if (value ==expect) {

value=update;return true;

}return false;

}finally{

lock.unlock();

}

}public final intgetAndIncrement() {

lock.lock();try{return value++;

}finally{

lock.unlock();

}

}public final intgetAndDecrement() {

lock.lock();try{return value--;

}finally{

lock.unlock();

}

}public final intincrementAndGet() {

lock.lock();try{return ++value;

}finally{

lock.unlock();

}

}public final intdecrementAndGet() {

lock.lock();try{return --value;

}finally{

lock.unlock();

}

}publicString toString() {returnInteger.toString(get());

}

}

ReadWriteLock 读写锁

读写锁：可以被多个读者访问或者被一个写者访问。读写锁提供读写分离功能。

public interfaceReadWriteLock {

Lock readLock();

Lock writeLock();

}

特性：

读-读不互斥：读读之间不阻塞。

读-写互斥：读阻塞写，写也会阻塞读。

写-写互斥：写写阻塞。

ReadWriteLock最大的特性就是读读共享(不互斥)，例如A线程读锁正在进行读取操作，此时如果B线程请求读锁，那么B线程可以马上顺利获得读锁而无需等待，但此时如果C线程请求写锁，那么C线程需要等待锁可用。

ReadWriteLock由于提供了读读共享而增加了复杂性，所以在读写都相当频繁的场景并不能体现出性能优势，只有在读操作极多而写操作极少的场景下才能体现其性能优势。比如，一个应用系统安装完成后需要导入一批维护性的初始化数据，这些数据可以通过界面修改，但需要修改的情况极少，当系统一启动就会自动加载初始化数据到指定数据结构(如HashMap)供各个模块读取使用，那么可以为这些数据的读写加ReadWriteLock，以提高读取性能并保持数据的一致性。

ReentrantReadWriteLock 实现类

ReentrantReadWriteLock类是ReadWriteLock接口的一个实现，它与ReentrantLock类一样提供了公平竞争与不公平竞争两种机制，默认也是使用非公平竞争机制。ReentrantLock是排他锁，使用非公平竞争机制时，抢占的机会相对还是比较少的，只有当新请求恰逢锁释放时才有机会抢占，所以发生线程饥饿的现象几乎很少。然而ReentrantReadWriteLock是共享锁，或者说读读共享，并且经常使用于读多写少的场景，即请求读操作的线程多而频繁而请求写操作的线程极少且间隔长，在这种场景下，使用非公平竞争机制极有可能造成写线程饥饿。比如，R1线程此时持有读锁且在进行读取操作，W1线程请求写锁所以需要排队等候，在R1释放锁之前，如果R2,R3,...,Rn 不断的到来请求读锁，因为读读共享，所以他们不用等待马上可以获得锁，如此下去W1永远无法获得写锁，一直处于饥饿状态。所以使用ReentrantReadWriteLock类时，小心选择公平机制，以免遇到出乎预料的结果。

最后，Java5的读写锁实现有瑕疵，可能发生死锁，在Java6已经修复，所以避免使用Java5读写锁。

例：创建读锁与写锁。

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

例：读写锁的经典应用，实现一个简单的缓存

importjava.util.HashMap;importjava.util.Map;importjava.util.concurrent.locks.ReadWriteLock;importjava.util.concurrent.locks.ReentrantReadWriteLock;/*** 用读写锁实现的一个缓存系统，读的时候可以并发执行，当缓存中没有数据时，要到数据库中查询数据.

* 此时只能写数据，不能读数据。当完数据之后，又可以并发地读取数据。这样做的话，可以提高系统的效率.*/

public classMyCacheSystem {//定义一个map用来存放要缓存起来的数据

private Map cache = new HashMap();private ReadWriteLock rwl = newReentrantReadWriteLock();//该方法中，读数据可以并发地读取，写数据与读数据，写数据与写数据之间不能并发地运行

publicObject getData(String key) {//刚进来的时候，上一把写锁

rwl.readLock().lock();

Object obj= null;try{

obj=cache.get(key);if (obj == null) {//如果数据为空，则需要到数据库中查询数据，所以这时候把读锁释放掉，上一把写锁，不能同时写数据//在上写锁之前，首先要把读锁释放掉

rwl.readLock().unlock();

rwl.writeLock().lock();//查询数据库的代码

try{//必须重新检查obj是否为空，因为这时候，另外一个线程可能会获得写锁，从而让obj有值

if (obj == null) {

obj= "查询数据库得到的数据";

}

}finally{

rwl.writeLock().unlock();

}//因为前面释放了写锁，所以这里要把写锁重新锁上

rwl.readLock().lock();

}

}finally{

rwl.readLock().unlock();

}returnobj;

}

}

关于读写锁的一些知识：

1．重入方面其内部的WriteLock可以获取ReadLock，但是反过来ReadLock想要获得WriteLock则永远都不要想。

2．WriteLock可以降级为ReadLock，顺序是：先获得WriteLock再获得ReadLock，然后释放WriteLock,这时候线程将保持Readlock的持有。反过来ReadLock想要升级为WriteLock则不可能。

3．ReadLock可以被多个线程持有并且在作用时排斥任何的WriteLock，而WriteLock则是完全的互斥.这一特性最为重要，因为对于高读取频率而相对较低写入的数据结构，使用此类锁同步机制则可以提高并发量。

4．不管是ReadLock还是WriteLock都支持Interrupt，语义与ReentrantLock一致。

5．WriteLock支持Condition并且与ReentrantLock语义一致，而ReadLock则不能使用Condition，否则抛出UnsupportedOperationException异常。