在Java中，除了使用synchronized关键字实现线程同步，还可以使用java.util.concurrent.locks包下的重入锁（ReentrantLock）来实现同步。今天我们就来学习ReentrantLock同步。
以下是本文包含的知识点：
1.Lock接口介绍
2.ReentrantLock的使用
3.ReentrantLock与synchronized实现同步的区别
4.ReadWriteLock介绍
5.Condition使用
一、Lock接口介绍
ReentrantLock实现自Lock接口，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()：获取锁。如果锁可用，则获取锁，否则进行等待。
tryLock()：如果锁可用，则获取锁，并立即返回值 true，否则返回 false，不会等待。
tryLock(long time, TimeUnit unit)：如果在给定的等待时间内，锁可用，则获取锁，并立即返回值 true，否则返回false。
lockInterruptibly()：获取锁，等待可中断。如果锁可用，并且当前线程未被中断，则获取锁，否则进行等待。如果被其它线程中断，则抛出InterruptException异常。
unlock()用来释放锁，newCondition()后面再讲。
因为采用Lock获取锁，必须手动释放锁，并且在发生异常时也不会自动释放锁，所以lock()/unlock()一般配合try/finally语句块来完成，通常使用形式如下：
Lock lock = ...;
lock.lock();//获取锁
try{
//处理任务
}catch(Exception e){
}finally{
lock.unlock();//释放锁
}
二、ReentrantLock的使用
ReentrantLock除了实现Serializable接口外，唯一实现Lock接口，下面来看看它的用法：
public class ReentrantLockTest {
private Lock lock = new ReentrantLock(); //lock要定义为成员变量，第个线程都共享这个锁
private List arrList = new ArrayList();
public static void main(String[] args) {
final ReentrantLockTest test = new ReentrantLockTest();
new Thread(){
public void run(){
test.testLock(Thread. currentThread());
}
}.start();
new Thread(){
public void run(){
test.testLock(Thread. currentThread());
}
}.start();
}
/**
* lock方法
* @param thread
*/
public void testLock(Thread thread){
//Lock lock = new ReentrantLock();//注意这里，并不会达到互斥的效果
//因为在testLock 方法中的lock变量是局部变量，每个线程执行该方法时都会保存一个副本，那么理所当然每个线程执行到lock.lock()处获取的是不同的锁，所以就不会发生冲突。解决办法：变成全局的，所有线程共享
lock.lock();//lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。
try {
System. out.println(thread.getName()+"得到了锁" );
for(int i=0; i<5; i++){
arrList.add(i);
}
} catch (Exception e) {
e.printStackTrace();
} finally{
System. out.println(thread.getName()+"释放了锁" );
lock.unlock();//unlock总是与lock成对出现，且一般采用try,catch,finally的方式
}
}
/**
* tryLock方法
* tryLock(long time, TimeUnit unit)方法
* @param thread
*/
public void testTryLock(Thread thread){
if(lock .tryLock()){//tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
//tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。
try {
System. out.println(thread.getName()+"得到了锁" );
for(int i=0; i<5; i++){
arrList.add(i);
}
} catch (Exception e) {
e.printStackTrace();
} finally{
System. out.println(thread.getName()+"释放了锁" );
lock.unlock();
}
} else{
System. out.println(thread.getName()+"获取锁失败" );
}
}
}
Thread-0得到了锁
Thread-0释放了锁
Thread-1得到了锁
Thread-1释放了锁
lockInterruptibly()：获取锁，等待可中断实例：
public class TestLockInterruptibly {
private Lock lock = new ReentrantLock();
public static void main(String[] args) {
TestLockInterruptibly test = new TestLockInterruptibly();
MyThread thread1 = new MyThread(test);
MyThread thread2 = new MyThread(test);
thread1.start();
thread2.start();
try {
Thread. sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread2.interrupt();
}
public void testLockInterruptibly(Thread thread) throws InterruptedException{
lock.lockInterruptibly(); //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出
try {
System. out.println(thread.getName()+"得到了锁" );
long startTime = System.currentTimeMillis();
for( ; ;) {
if(System.currentTimeMillis() - startTime >= Integer.MAX_VALUE )
break;
//。。。
}
}
finally {
System. out.println(Thread.currentThread().getName()+ "执行finally");
lock.unlock();
System. out.println(thread.getName()+"释放了锁" );
}
}
}
class MyThread extends Thread {
private TestLockInterruptibly test = null ;
public MyThread(TestLockInterruptibly test) {
this.test = test;
}
@Override
public void run() {
try {
test.testLockInterruptibly(Thread.currentThread());
} catch (InterruptedException e) {
System. out.println(Thread.currentThread().getName()+ "被中断");
}
}
}
Thread-0得到了锁
Thread-1被中断
可以看到thread2 被中断了
三、ReentrantLock与synchronized实现同步的区别
相同点：
１.实现同步功能
2.都具有线程重入性
不同点：
1.代码写法上，ReentrantLock为API层面互斥锁，synchronized为原生语法层面互斥锁。
2.功能上，ReentrantLock比synchronized提高了更高级的功能：
等待可中断，
可实现公平锁，
锁可以绑定多个条件。
等待可中断是指当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待。可中断特性对执行时间非常长的同步块很有帮助。Lock的lockInterruptibly()方法就是等待可中断实现。
公平锁是指多个线程在等待同一个锁时，必须按申请锁的时间顺序依次获取锁；而非公平锁则不能保证这一点，在锁被释放的时候，任何一个线程都有机会获得锁。synchronized是非公平锁，ReentrantLock默认是非公平锁，但可以通过带布尔值的构造方法要求使用公平锁。
ReentrantLock构造器源码：
//默认为非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
//可以通过带布尔值的构造方法要求使用公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
3.性能上，Jdk6加入了很多针对锁的优化，synchronized与ReentrantLock的性能基本上完全持平了。性能因素不再是选择ReentrantLock的理由，虚拟机未来在性能改进中肯定也会更加偏向于原生的synchronized，所以还是优先考虑使用synchrozied进行同步。
四、ReadWriteLock介绍
ReadWriteLock也是一个接口，它只定义了两个方法：
public interface ReadWriteLock {
/**
* Returns the lock used for reading.
*
* @return the lock used for reading.
*/
Lock readLock();
/**
* Returns the lock used for writing.
*
* @return the lock used for writing.
*/
Lock writeLock();
}
ReentrantReadWriteLock类实现了ReadWriteLock接口。我们来看下多个线程同时获取读取锁的情况：
public class ReadWriteLockTest {
private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public static void main(String[] args) {
final ReadWriteLockTest test = new ReadWriteLockTest();
new Thread(){
public void run(){
test.get2(Thread. currentThread());
}
}.start();
new Thread(){
public void run(){
test.get2(Thread. currentThread());
}
}.start();
}
/**
* readLock方法：使用多个线程同时执行
* @param thread
*/
public void get2(Thread thread) {
readWriteLock.readLock().lock();
try {
long start = System.currentTimeMillis();
while(System.currentTimeMillis() - start <= 1) {
System. out.println(thread.getName()+"正在进行读操作" );
}
System. out.println(thread.getName()+"读操作完毕" );
} finally {
readWriteLock.readLock().unlock();
}
}
}
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1读操作完毕
Thread-0读操作完毕
不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。
四、Condition使用
synchronized与wait()和nitofy()/notifyAll()方法相结合可以实现等待/通知模型，ReentrantLock同样可以，但是需要借助Condition，且Condition有更好的灵活性，具体体现在：
1、一个Lock里面可以创建多个Condition实例，实现多路通知
2、notify()方法进行通知时，被通知的线程时Java虚拟机随机选择的，但是ReentrantLock结合Condition可以实现有选择性地通知，这是非常重要的
看一下利用Condition实现等待/通知模型的最简单用法，下面的代码注意一下，await()和signal()之前，必须要先lock()获得锁，使用完毕在finally中unlock()释放锁，这和wait()/notify()/notifyAll()使用前必须先获得对象锁是一样的：
import java.util.PriorityQueue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionTest {
private int queueSize = 10;
private PriorityQueue queue = new PriorityQueue(queueSize);
private Lock lock = new ReentrantLock();
private Condition notFull = lock.newCondition();
private Condition notEmpty = lock.newCondition();
public static void main(String[] args) {
ConditionTest test = new ConditionTest();
Producer producer = test.new Producer();
Consumer consumer = test.new Consumer();
producer.start();
consumer.start();
}
class Consumer extends Thread {
@Override
public void run() {
consume();
}
private void consume() {
while (true) {
lock.lock();
try {
while (queue.size() == 0) {
try {
System.out.println("队列空，等待数据");
notEmpty.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
queue.poll(); // 每次移走队首元素
notFull.signal();
System.out.println("从队列取走一个元素，队列剩余" + queue.size() + "个元素");
} finally {
lock.unlock();
}
}
}
}
class Producer extends Thread {
@Override
public void run() {
produce();
}
private void produce() {
while (true) {
lock.lock();
try {
while (queue.size() == queueSize) {
try {
System.out.println("队列满，等待有空余空间");
notFull.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
queue.offer(1); // 每次插入一个元素
notEmpty.signal();
System.out.println("向队列取中插入一个元素，队列剩余空间："
+ (queueSize - queue.size()));
} finally {
lock.unlock();
}
}
}
}
} Condition的await()方法是释放锁的，原因也很简单，要是await()方法不释放锁，那么signal()方法又怎么能调用到Condition的signal()方法呢？
注意要是用一个Condition的话，那么多个线程被该Condition给await()后，调用Condition的signalAll()方法唤醒的是所有的线程。如果想单独唤醒部分线程该怎么办呢？new出多个Condition就可以了，这样也有助于提升程序运行的效率。使用多个Condition的场景是很常见的，像ArrayBlockingQueue里就有。
参考
《深入Java 虚拟机》
http://www.cnblogs.com/dolphin0520/p/3923167.html