class="MsoNormal">（三）线程同步ReentrantLock，condition（await,signal）
一．synchronized和ReentrantLock?故事
1. 我们前面（二）java 的线程同步（synchronized ,wait,notify）讲了synchronized的同步方法，java 就是这么神奇，这里又有一个同步的方法！当然，长江后浪推前浪，后者肯定比前者是由优越之处的。
先看看?synchronized?的一些限制：?
? ???1.1?：无法中断正在等候获取一个锁的线程?
? ???1.2?：无法通过投票得到一个锁?
? ???1.3?：释放锁的操作只能与获得锁所在的代码块中进行，无法在别的代码块中释放锁?。
?
?ReentrantLock?类实现了?Lock?，它拥有与?synchronized?相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。
定时锁等候：设置定时等候之后，在这个等候时间内如果没有获得这个锁，这个线程就会自己中断。
可中断锁等候：就是线程等候可以自己中断也可以别人中断。
锁投票：这个不太懂，有懂的大牛给提示一下，我到时引用到博文里面来（会注明作者的）。
?
二．ReentrantLock?的简单用法：
?????? 1.lock() 和unlock()：ReentrantLock手动获取和释放锁，一般放在try catch 块中。如下所示
class X {
private final ReentrantLock lock = new ReentrantLock();
// ...
public void m() {
lock.lock(); // block until condition holds
try {
// ... 同步的代码
} finally {
lock.unlock()
}
}
}
?
??? 2.既然有锁，那多个线程下面的阻塞注明做到呢？这就需要用到Condiction类了，这个类的作用就相当于给ReentrantLock加类似synchronized的wait,notify方法，不过它更强大！它的await可以有条件的等待，比如定时等待等用法，为方便比较，我结合前面synchronized的例子改一下，例子如下所示：
?
package com.hxw.Threads;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ProducerConsumeGameLock {
/**
* @param args
*/
public static void main(String[] args) {
Bucket bucket = new Bucket(); // 构造篮子
new Thread(new Producer(bucket),"Producer线程").start();
new Thread(new Consumer(bucket),"Consumer线程").start();
}
}
final class Consumer implements Runnable {
private Bucket bucket;
public Consumer(Bucket bucket) {
this.bucket = bucket;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
bucket.get();
}
}
}
final class Producer implements Runnable {
private Bucket bucket;
public Producer(Bucket bucket) {
this.bucket = bucket;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) { // 来回十次交易
bucket.put((int) (Math.random() * 1000));
}
}
}
class Bucket {
private int packOdBalls;
private boolean available = false;
private final ReentrantLock lock = new ReentrantLock();
private Condition noBull = lock.newCondition();
private Condition fullBull = lock.newCondition();
public int get() { // 消费者从篮子里面取出球
lock.lock();
try {
while (available == false) { // 如果没有就等着,但是为什么不是if呢？后面会做解析
System.out.println("消费者：暂时没有球可以消费我就等着...");
noBull.await(); // wait();
}
System.out.println("消费者获得了" + packOdBalls + "个球");
available = false;
System.out.println("持有消费线程数： "+lock.getHoldCount());
fullBull.signal(); // notify();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
// 有的话就取出来
return packOdBalls;
}
public synchronized void put(int packOdBalls) { // 生产者将生产球并放入到篮子里面
lock.lock();
try {
while (available) {
System.out.println("生产者：既然篮子里面已经有球了我就消费完了再生产吧！");
fullBull.await(); // wait();
}
this.packOdBalls = packOdBalls;
available = true;
System.out.println("生产者放进去了" + packOdBalls + "个球");
noBull.signal(); // notify();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
?
【运行结果与前面一样，需要看的可以戳文章头的链接】
?
三．ReentrantLock的方法…
? 1. public boolean tryLock():
仅在调用时锁未被另一个线程保持的情况下，才获取该锁。 这个方法会完全忽略公平策略，理解trylock的意思就知道了，就是“努力试着去锁”，所以一旦这个锁没有线程持有，他就抢占了！
2. public boolean tryLock(long timeout,TimeUnit unit):
如果锁在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁。说的详细点如果超出了指定的等待时间，则返回值为 false。如果该锁没有被另一个线程保持，并且立即返回 true 值，则将锁的保持计数设置为 1。如果为了使用公平的排序策略，已经设置此锁，并且其他线程都在等待该锁，则不会 获取一个可用的锁。这与 tryLock() 方法相反。如果想使用一个允许闯入公平锁的定时 tryLock，那么可以将定时形式和不定时形式组合在一起：
if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... }
注意：有的人可能不理解这两个参数，其实就是前面是数词，后面是量词（SECOND，HOUR等等）
3. public int getHoldCount()查询当前线程保持此锁的次数。
4. public boolean isLocked()查询此锁是否由任意线程保持。
等等还有很多方法，这些查询方法都只能叫监控方法，因为线程无时无刻不在变化，可能返回这个值的下一纳秒，这个值就变了
5.还有一个构造方法：
public ReentrantLock(boolean fair)
创建一个具有给定公平策略的 ReentrantLock。
?
四．Condition方法一览…
1.await():
让当前线程一直处于等待状态，直到唤醒或中断。需要注意的是，这里说的是当前线程，这个“当前”指的是这个await所属Condition对象的线程创建者，这一点从上面的源码也可以看出（我们每个线程都new了一个Condition）。
对于唤醒，这里有个虚假唤醒，虚假唤醒也会引起当前线程唤醒，我们后面来讨论
2. boolean await(long time,TimeUnit unit)：
让当前线程在指定时间内一直处于等待状态，直到被唤醒或中断。
3. void signal()：唤醒一个等待线程。这个与notify功能类似
4. void signalAll()：唤醒所有等待线程。这个与notifyAll功能类似
?
五．虚假唤醒
虚假唤醒简而言之就是一个signal()可能唤醒了多个线程，前面代码第60行左右提到过。当然这个概率是很低的，你会发现，你把while改成if也是可以运行的。但是我们也要避免这种情况，所以我们就改成了while，while()不仅仅在等待条件变量前检查条件变量，实际上在等待条件变量后也检查条件变量。
?
这样对condition进行多做一次判断，即可避免“虚假唤醒”.
相关文章
