Java ：ReentrantLock类和Condition类
锁机制之ReentrantLock
简单概念
可重入锁，Java自己实现的锁，继承了Lock类，有两种构造。
- 锁：在同一时间点只能被一个线程所持有
- 可重入：锁可以被已经占有它的线程多次获取
ReentrantLock在同一个时间点只能被一个线程获取(当某线程获取到“锁”时，其它线程就必须等待)；ReentraantLock是通过一个FIFO的等待队列来管理获取该锁所有线程的。在“公平锁”的机制下，线程依次排队获取锁；而“非公平锁”在锁是可获取状态时，不管自己是不是在队列的开头都会获取锁。
比较synchronized
相同: ReentrantLock提供了synchronized类似的功能和内存语义。
不同
[1]与synchronized相比，ReentrantLock提供了更多，更加全面的功能，具备更强的扩展性。例如：时间锁等候，可中断锁等候，锁投票。
[2]ReentrantLock还提供了条件Condition，对线程的等待、唤醒操作更加详细和灵活，所以在多个条件变量和高度竞争锁的地方，ReentrantLock更加适合（下面会阐述Condition）。
[3]ReentrantLock提供了可轮询的锁请求。它会尝试着去获取锁，如果成功则继续，否则可以等到下次运行时处理，而synchronized则一旦进入锁请求要么成功，要么一直阻塞，所以相比synchronized而言，ReentrantLock会不容易产生死锁些。
[4]ReentrantLock支持更加灵活的同步代码块，但是使用synchronized时，只能在同一个synchronized块结构中获取和释放。注：ReentrantLock的锁释放一定要在finally中处理，否则可能会产生严重的后果。
[5]ReentrantLock支持中断处理，且性能较synchronized会好些。
重入
有一个与锁相关的获取计数器，如果拥有锁的某个线程再次得到锁，那么获取计数器就加1，然后锁需要被释放两次才能获得真正释放。
- 线程再次获取锁：锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。
- 锁的最终释放：线程重复n次获取了锁，随后在n次释放该锁后，其他线程能够获取该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时表示锁已经释放。
公平/非公平锁
通过构造方法实现，默认非公平锁。且非公平锁性能高于公平锁性能。
如果获取一个锁是按照请求的顺序得到的，那么就是公平锁，否则就是非公平锁，允许线程插队。
公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序。而非公平锁就是一种获取锁的抢占机制，是随机获得锁的，和公平锁不一样的就是先来的不一定先得到锁，这个方式可能造成某些线程一直拿不到锁，结果也就是不公平的了。
tryLock方法
- 实现可轮询的锁请求：仅在调用时锁为空闲状态才获取该锁。如果锁可用，则获取锁，并立即返回值true。如果锁不可用，则此方法将立即返回值false。
- 实现可定时的锁请求：如果活动在期待的时间内没能获得结果，定时锁能使程序提前返回。可定时的锁获取模式，由tryLock(long, TimeUnit)方法实现。
示例
// 简单示例
public class ReentrantLockThread implements Runnable {
ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
lock.lock();
try {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName() + "输出：" + i);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
ReentrantLockThread thread1 = new ReentrantLockThread();
new Thread(thread1, "a").start();
new Thread(thread1, "b").start();
}
}
// 锁的重入
public class TestRetryLock {
ReentrantLock lock = null;
public TestRetryLock() {
lock = new ReentrantLock();
}
public static void main(String[] args) {
TestRetryLock retryLock = new TestRetryLock();
try {
retryLock.testReentry(1);
// 能执行到这里而不阻塞，表示锁可重入
retryLock.testReentry(2);
retryLock.testReentry(3);
} finally {
// 释放重入测试的锁，要按重入的数量解锁，否则其他线程无法获取该锁。
retryLock.getLock().unlock();
retryLock.getLock().unlock();
retryLock.getLock().unlock();
}
}
public ReentrantLock getLock() {
return lock;
}
public void testReentry(int count) {
lock.lock();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
System.out.println(sdf.format(new Date()) + " " + Thread.currentThread().getName()
+ " get lock. " + count);
}
}
// 公平和非公平锁
public class LockService {
private ReentrantLock lock;
public LockService(boolean fair){
lock = new ReentrantLock(fair);
}
public void serviceMethod() {
lock.lock();
try {
System.out.println("ThreadName=" + Thread.currentThread().getName() + " 获得锁定");
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
LockService lockService = new LockService(true);
Runnable runnable = () -> {
System.out.println("**线程： " + Thread.currentThread().getName() + " 运行了 ");
lockService.serviceMethod();
};
for (int i = 0; i < 10; i++) {
new Thread(runnable).start();
}
}
}
Condition
简单概念
Condition类能实现synchronized和wait、notify搭配的功能，另外比后者更灵活，Condition可以实现多路通知功能，也就是在一个Lock对象里可以创建多个Condition（即对象监视器）实例，线程对象可以注册在指定的Condition中，从而可以有选择的进行线程通知，在调度线程上更加灵活。而synchronized就相当于整个Lock对象中只有一个单一的Condition对象，所有的线程都注册在这个对象上。线程开始notifyAll时，需要通知所有的WAITING线程，没有选择权，会有相当大的效率问题。
-
Condition是个接口，基本的方法就是await()和signal()方法。
-
Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()
-
调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用。
-
Conditon中的await()对应Object的wait()，Condition中的signal()对应Object的notify()，Condition中的signalAll()对应Object的notifyAll()。
-
condition是跟着线程来的，即一个线程可以拥有一个condition，而不是一个ReentrantLock拥有一个condition
示例
// 简单示例
public class ConditionService {
// 实例化一个ReentrantLock对象
private ReentrantLock lock = new ReentrantLock();
// 为线程A注册一个Condition
public Condition conditionA = lock.newCondition();
// 为线程B注册一个Condition
public Condition conditionB = lock.newCondition();
public void awaitA() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "进入了awaitA方法");
long timeBefore = System.currentTimeMillis();
// 执行conditionA等待
conditionA.await();
long timeAfter = System.currentTimeMillis();
System.out.println(Thread.currentThread().getName() + "被唤醒");
System.out.println(Thread.currentThread().getName() + "等待了: " + (timeAfter - timeBefore) / 1000 + "s");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void awaitB() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "进入了awaitB方法");
long timeBefore = System.currentTimeMillis();
// 执行conditionA等待
conditionB.await();
long timeAfter = System.currentTimeMillis();
System.out.println(Thread.currentThread().getName() + "被唤醒");
System.out.println(Thread.currentThread().getName() + "等待了: " + (timeAfter - timeBefore) / 1000 + "s");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void signallA() {
lock.lock();
try {
System.out.println("启动唤醒程序");
// 唤醒所有注册conditionA的线程
conditionA.signalAll();
} finally {
lock.unlock();
}
}
public void signallB() {
lock.lock();
try {
System.out.println("启动唤醒程序");
// 唤醒所有注册conditionB的线程
conditionB.signalAll();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
ConditionService conditionService = new ConditionService();
new Thread(() -> conditionService.awaitA(), "A").start();
new Thread(() -> conditionService.awaitB(), "B").start();
Thread.sleep(2000);
// 唤醒持有ConditionA的线程
conditionService.signallA();
Thread.sleep(2000);
// 唤醒持有ConditionB的线程
conditionService.signallB();
}
// 生产者消费者模式
public class SomethingFactory {
/**
* 工厂最大库存容量
*/
public static final int MAX_SIZE = 10;
private int currentNumber = 0;
private ReentrantLock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void produce(int needNum) {
lock.lock();
try {
while (currentNumber + needNum > MAX_SIZE) {
System.out.println("要生产的产品数量" + needNum + "超过剩余库存量" + (MAX_SIZE - currentNumber) + "，暂时不能执行生产任务!");
condition.await();
}
System.out.println(Thread.currentThread().getName() + "---生产商品---");
currentNumber += needNum;
System.out.println("已经生产了" + needNum + "个产品，现仓储量为" + currentNumber);
// 通知消费者
condition.signalAll();
} catch (Exception e) {
} finally {
lock.unlock();
}
}
public void consume(int needNum) {
lock.lock();
try {
while (currentNumber < needNum) {
System.out.println("要消费的产品数量" + needNum + "超过剩余库存量" + (currentNumber) + "，暂时不能执行消费任务!");
condition.await();
}
System.out.println(Thread.currentThread().getName() + "---消费商品---");
currentNumber -= needNum;
System.out.println("已经消费了" + needNum + "个产品，现仓储量为" + currentNumber);
// 提醒生产者生产
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) {
SomethingFactory factory = new SomethingFactory();
new Thread(() -> {
int count = 0;
while (count++ < 5) {
factory.consume(1);
}
}, "consumer-A").start();
new Thread(() -> {
int count = 0;
while (count++ < 5) {
factory.produce(1);
}
}, "producer").start();
new Thread(() -> {
int count = 0;
while (count++ < 5) {
factory.consume(1);
}
}, "consumer-B").start();
}