在Java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在JDK1.5中新增加了ReentrantLock类也能达到同样的效果，并且在扩展功能上也更加强大，比如具有嗅探锁定、多路分支通知等功能，而且在使用上也比synchronized更加的灵活。
调用ReentrantLock对象的lock（）方法获取锁，调用unlock（）方法释放锁。调用了lock.lock（）代码的线程就持有了“对象监视器”，其他线程只有等待锁被释放时再次争抢。效果和使用synchronized关键字一样，线程之间执行的顺序是随机的。
1.使用Condition实现等待／通知：
关键字synchronized与wait（）和notify（）／notifyAll（）方法相结合可以实现等待／通知模式，类ReentrantLock也可以实现同样的功能，但需要借助于Condition对象，也就是在一个Lock对象里面可以创建多个Condition（即对象监视器）实例，线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度上更加灵活。
在使用notify（）／notifyAll（）方法进行通知时，被通知的线程却是由JVM随机选择的。但使用ReentrantLock结合Condition类是可以实现前面介绍过的“选择性通知”，这个功能是非常重要的，而且在Condition类中是默认提供的。
而synchronized就相当于整个Lock对象中只有一个单一的Condition对象，所有的线程都注册在它一个对象的身上。线程开始notifyAll时，需要通知所有的WAITING线程，没有选择权，会出现相当大的效率问题。
使用condition实现等待／通知代码：
public class MyService｛
private Lock lock = new ReentrantLock();
public void await(){
lock.lock();
System.out.println("await时间为"＋System.currentTimeMillis());
Condition.await();
lock.unlock();
}
public void signal(){
lock.lock();
System.out.println("await时间为"＋System.currentTimeMillis());
condition.signal();
lock.unlock();
}
｝
public class ThreadA extends Thread{
private MyService service;
public ThreadA(MyService service){
super();
this.service = service;
}
@Override
public void run(){
service.await();
}
}
public class Run{
public static void main(String[] args){
MyService service = new MyService();
ThreadA a = new ThreadA(service);
a.start();
Thread.sleep(3000);
service.signal();
}
}
Object类中的wait（）方法相当于Condition类中的await（）方法。
Object类中的wait（long timeout）方法相当于Condition类中的await（long time，TimeUnit unit）方法。
Object类中的notify（）方法相当于Condition类中的signal（）方法。
Object类中的notifyAll（）方法相当于Condition类中的signalAll（）方法。
2.使用多个Condition实现通知部分线程：
1>先实例化多个condition对象；
Condition conditionA ＝ lock.newCondition();
Condition conditionB ＝ lock.newCondition();
2>在不同的方法中令conditionA／conditionB这两个signalAll（）
3.公平锁与非公平锁
公平与非公平锁：锁Lock分为“公平锁”和“非公平锁”，公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序。而非公平锁就是一种获取锁的抢占机制，是随机获得锁的，和公平锁不一样的就是先来的不一定先得到锁，这个方式可能造成某些线程一直拿不到锁，结果也就是不公平的了。
4.ReentrantLock类中的方法：
1>getHoldCount():查询当前线程保持此锁定的个数，也就是调用lock()方法的次数。
2>getQueueLength()的作用是返回正等待获取此锁定的线程估计数，比如有5个线程，一个线程首先执行await（）方法，那么在调用getQueueLength()方法后返回值是4，说明有4个线程同时在等待lock的释放。
3>方法getWaitQueueLength(Condition condition)的作用是返回等待与此锁定相关的给定条件Condition的线程估计数，比如有5个线程，每个线程都执行了同一个condition对象的await()方法，则调用getWaitQueueLength(Condition condition)方法时返回的int值是5.
4>方法boolean hasQueuedThread（Thread thread）的作用是查询制定的线程是否正在等待获取此锁定。
5>方法boolean hasWaiters(Condition condition)的作用是查询是否有线程正在等待于此锁定有关的condition条件。
6>方法boolean isFair()的作用是判断是不是公平锁。
在默认情况下，ReentrantLock类使用的是非公平锁。
7>方法boolean isHeldByCurrentThread()的作用是查询当前线程是否保持此锁定
8>方法boolean isLocked()的作用是查询此锁定是否由任意线程保持。
ReentrantReadWriteLock：类ReentrantLock具有完全互斥排他的效果，即同一时间只有一个线程在在执行ReentrantLock.lock()方法后面的任务。这样做虽然保证了实例变量的线程安全，但效率却十分底下。所以在JDK中提供了一种读写锁ReentrantReadWriteLock类，使用它可以加快运行效率，在某些不需要操作实例变量的方法中，完全可以使用读写锁ReentrantReadWriteLock来提升该方法的代码运行速度。
读写锁表示也有两个锁，一个是读操作相关的锁，也称为共享锁；另一个是写操作相关的锁，也叫排他锁。也就是多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥，在没有线程Thread进行写入操作时，进行读取操作的多个Thread都可以获取读锁，而进行写入操作的Thread只有在获取写锁后才能进行写入操作。即多个Thread都可以同时进行读取操作，但是同一时刻只允许一个Thread进行写入操作。
