线程的安全性与Java锁Lock接口的简介与使用

在线程的安全性与synchronized的使用与锁升级一篇我们介绍了线程的安全性与synchronized解决方案，以及锁的升级过程，在该篇中我们知道synchronized是阻塞式的锁，对于性能有很大的影响。而Java SE 5之后，并发包中新增 了Lock接口（以及相关实现类）用来实现锁功能，它提供了与synchronized关键字类似的同步功 能，只是在使用时需要显式地获取和释放锁，这篇内容我们将会介绍并发包中的工具锁重入锁ReentrantLock和读写锁ReentrantReadWriteLock。

在介绍重入锁ReentrantLock和读写锁ReentrantReadWriteLock之前，我们先简单的了解一下Lock接口，Lock接口定义了锁获取和释放的基本操作，其提供的API如下表：

在Java并发包，即我们常说的JUC中Lock的实现类有ReentrantLock，ReadLock，WriteLock三种，其中ReadLock，WriteLock为ReentrantReadWriteLock的内部类，它还实现了ReadWriteLock接口，我们主要讲解ReentrantLock和ReentrantReadWriteLock的使用，如下为ReadWriteLock接口的定义：

public interface ReadWriteLock {
    //获取读锁
    Lock readLock()；
    //获取写锁
    Lock writeLock();
}

重入锁ReentrantLock，顾名思义，就是支持重进入的锁，它表示该锁能够支持一个线程对 资源的重复加锁。除此之外，该锁的还支持获取锁时的公平和非公平性选择,即公平锁与非公平锁，所谓公平锁就是如果在绝对时间上，先对锁进行获取的请求一定先 被满足，那么这个锁是公平的，反之，是不公平的。公平的获取锁，也就是等待时间最长的线 程最优先获取锁，也可以说锁获取是顺序的。下面我们介绍下ReentrantLock的使用，我们可以通过构造创建一个ReentrantLock实例，如下所示，ReentrantLock提供了两个构造方法，一个为非公平锁，一个为公平锁，我们使用非公平锁作为示例：

//默认为非公平锁
public ReentrantLock() {
   sync = new NonfairSync();
}
//创建公平锁
public ReentrantLock(boolean fair) {
  sync = fair ? new FairSync() : new NonfairSync();
}

如下代码我们创建两个线程，分别传入一个Lock接口实例，在线程中sleep 5秒钟。我们使用lock()方法获取锁，线程B与线程A代码类似，只是线程名称为线程B。

public class LockThreadA extends Thread {
    private Lock lock;
    public LockThreadA(Lock lock) {
        super("Thread A");
	this.lock = lock;
    }
    @Override
    public void run() {
        lock.lock();
        try {
            System.out.println("A 获取到锁 sleep 5 秒钟");
	    Thread.sleep(5000);
	} catch (InterruptedException e) {

	} finally {
	    System.out.println("A 释放锁");
	    lock.unlock();
	}
    }

}

public class LockDemo {
    public static void main(String[] args) throws InterruptedException {
        //获取Lock实例
        Lock lock = new  ReentrantLock();
	LockThreadA ta = new LockThreadA(lock);
	LockThreadB tb = new LockThreadB(lock);
	ta.start();
	tb.start();
    }
}

上面讲述的ReentrantLock排他锁，这些锁在同一时刻只允许一个线程进行访问，而读写锁在同一时刻可以允许多个读线程访问，但是在写线程访问时，所有的读 线程和其他写线程均被阻塞。Java并发包提供读写锁的实现是 ReentrantReadWriteLock，它提供的特性如下表所示。

在上面我们介绍了接口ReadWriteLock仅定义了获取读锁和写锁的两个方法，即readLock()方法和writeLock()方 法，而其实现——ReentrantReadWriteLock，除了接口方法之外，还提供了一些便于外界监控其 内部工作状态的方法，如下表所示：

上面我们简单介绍了ReentrantReadWriteLock的API方法，下面我们将会通过一个缓存示例说明读写锁的使用方式，如下我们通过HashMap作为缓存存储，我们都知道HashMap是非线程安全性的，而我们需要通过读写锁保证HashMap的线程安全性。

public class ReadWriteLockDemo {
    //缓存
    static Map<String, Object> map = new HashMap<String, Object>();
    //读写锁实例
    static ReentrantReadWriteLock rwlock = new ReentrantReadWriteLock();
    //获取读锁
    static Lock r = rwlock.readLock();
    //获取写锁
    static Lock w = rwlock.writeLock();
    public static Object put(String key, Object value) {
        //写锁
	w.lock();
	try {
	    return map.put(key, value);
	} finally {
	    //释放锁
	    w.unlock();
	}
    }
    public static Object get(String key) {
	//读锁
	r.lock();
	try {
	    return map.get(key);
	} finally {
	    //释放锁
	    r.unlock();
	}
    }
    public static final Object remove(String key) {
        //写锁
        w.lock();
        try {
            return map.remove(key);
        } finally {
	    //释放锁
	    w.unlock();
        }
    }
    public static final void clearAll() {
        //写锁
        w.lock();
        try {
            map.clear();
        } finally {
            //释放锁
            w.unlock();
        }
    }
}

 本篇博客只是Java中介绍除了synchronized的锁解决方案，这里并不介绍它们的使用原理，以为这里面涉及到并发包提供的一个同步队列AbstractQueuedSynchronizer的实现，学习AbstractQueuedSynchronizer之后再看这部分的具体实现就变得比较清楚了。下一篇博客我们就会介绍AbstractQueuedSynchronizer的简单使用。