Java并发——显示锁

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

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

排他锁又被称为独占锁，即读写互斥、写写互斥、读读互斥。
Java的ReadWriteLock是一种共享锁，提供读读共享，但读写和写写仍然互斥。

Lock接口

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

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    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 = new ReentrantLock();
 
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 class AtomicIntegerWithLock {
    private int value;
    private Lock lock = new ReentrantLock();
 
    public AtomicIntegerWithLock() {
        super();
    }
 
    public AtomicIntegerWithLock(int value) {
        this.value = value;
    }
 
    public final int get() {
        lock.lock();
        try {
            return value;
        } finally {
            lock.unlock();
        }
    }
 
    public final void set(int newValue) {
        lock.lock();
        try {
            value = newValue;
        } finally {
            lock.unlock();
        }
    }
 
    public final int getAndSet(int newValue) {
        lock.lock();
        try {
            int ret = value;
            value = newValue;
            return ret;
        } finally {
            lock.unlock();
        }
    }
 
    public final boolean compareAndSet(int expect, int update) {
        lock.lock();
        try {
            if (value == expect) {
                value = update;
                return true;
            }
            return false;
        } finally {
            lock.unlock();
        }
    }
 
    public final int getAndIncrement() {
        lock.lock();
        try {
            return value++;
        } finally {
            lock.unlock();
        }
    }
 
    public final int getAndDecrement() {
        lock.lock();
        try {
            return value--;
        } finally {
            lock.unlock();
        }
    }
 
    public final int incrementAndGet() {
        lock.lock();
        try {
            return ++value;
        } finally {
            lock.unlock();
        }
    }
 
    public final int decrementAndGet() {
        lock.lock();
        try {
            return --value;
        } finally {
            lock.unlock();
        }
    }
 
    public String toString() {
        return Integer.toString(get());
    }
 
}

ReadWriteLock 读写锁

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

public interface ReadWriteLock {
    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=new ReentrantReadWriteLock();
private static Lock readLock = readWriteLock.readLock();
private static Lock writeLock = readWriteLock.writeLock();

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

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
 
/**
 * 用读写锁实现的一个缓存系统，读的时候可以并发执行，当缓存中没有数据时，要到数据库中查询数据.
 * 此时只能写数据，不能读数据。当完数据之后，又可以并发地读取数据。这样做的话，可以提高系统的效率.
 */
public class MyCacheSystem {
 
    // 定义一个map用来存放要缓存起来的数据
    private Map<String, Object> cache = new HashMap<String, Object>();
 
    private ReadWriteLock rwl = new ReentrantReadWriteLock();
 
    // 该方法中，读数据可以并发地读取，写数据与读数据，写数据与写数据之间不能并发地运行
    public Object 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();
        }
 
        return obj;
    }
 
}

关于读写锁的一些知识：

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异常。