共计 2525 个字符，预计需要花费 7 分钟才能阅读完成。
在多线程中，1.5 版本之前，咱们都应用同步代码块或者同步办法来解决线程平安问题
比方：
同步代码块
synchronized(锁对象){
性能代码;
}
同步办法
public synchronized void test(){
性能代码;
}
// 首先实现共享数据
class Person{
String name;
boolean isMoney=true;
// 挣钱
public void zhengQian(){
synchronized(this){
while(!isMoney){
try{wait();}catch(Exception e){}
}
name=” 男人 ”;
System.out.println(www.sangpi.comThread.currentThread().getName()+name+”— 挣钱 —“);
isMoney=!isMoney;
notifyAll();// 叫醒所有
}
}
// 花钱
public void huaQian(){
synchronized(this){
while(isMoney){
try{wait();}catch(Exception e){}
}
name=”women。。。。人 ”;
System.out.println(Thread.currentThread().getName()+name+”— 花 ========= 钱 —“);
isMoney=!isMoney;
notifyAll();// 叫醒所有
}
}
}
// 输出线程
class In implements Runnable{
Person p=null;
In(Person p){
this.p=p;
}
public void run(){
while(true){
p.zhengQian();
}
}
}
// 输入线程
class Out implements Runnable{
Person p=null;
Out(Person p){
this.p=p;
}
public void run(){
while(true){
p.huaQian();
}
}
}
从代码中能够看出，对于同步代码块或者同步办法来说，都是以锁对象 this 来管制其锁定的代码的。
api 中也通知咱们：
Lock 实现提供了比应用 synchronized 办法和语句可取得的更宽泛的锁定操作。此实现容许更灵便页游的构造，能够具备差异很大的属性，能够反对多个相干的 Condition 对象。
那应用 Lock+Condition 怎么来实现呢?
代码如下：
import java.util.concurrent.locks.*;
class Person{
String name;
boolean isMoney=true;
Lock lock=new ReentrantLock();
Condition in=lock.newCondition();
Condition out=lock.newCondition();
// 挣钱
public void zhengQian(){
lock.lock();
try{
while(!isMoney){
try{in.wait();}catch(Exception e){}
}
name=” 男人 ”;
System.out.println(Thread.currentThread().getName()+name+”— 挣钱 —“);
isMoney=!isMoney;
out.signal();// 叫醒对方
}finally{
lock.unlock();
}
}
// 花钱
public void huaQian(){
lock.lock();
try{
while(!isMoney){
try{out.wait();}catch(Exception e){}
}
name=”women。。。。人 ”;
System.out.println(Thread.currentThread().getName()+name+”— 花 ========= 钱 —“);
isMoney=!isMoney;
in.signal();// 叫醒对方
}finally{
lock.unlock();
}
}
}
比照发现，Lock+Condition 的形式是应用 Condition 对象来具体操作现场的期待和唤醒的，
也就是对于生产线程有专属的生成线程的 Condition 对象，对生产线程有专属的生产线程的 Condition
对象，当期待或者唤醒时能够准确的管制是哪方线程，同步代码块或者同步办法在唤醒时，不能准确的
唤醒对方，所以只能唤醒全副，这时候减少了线程的判断次数，显著，Lock+Condition 是优于 synchronized 的形式的
接下来咱们剖析下 Lock 和 Condition 的关系
Lock 的子类对象是来取代 synchronized 的，也就是锁，Condition 只是锁的操作对象
取代的是以前的锁对象，都领有期待和唤醒的办法，尽管名字不同，Condition 次要是对锁的操作对象
一个 Lock 对象，创立进去三个 Condition 对象 x,y,z
也就是当前执行这个锁的线程将会被分成三类线程，比方如果执行 x.await()，执行这段代码的
三个绿色线程将会进入期待状态，再比方 z 中三个红色线程都处于期待状态，如果执行 z.signal(), 将会唤醒执行 z 的三个红色线程中的某一个，这样代码就能够失常运行了。
蓝色线两侧别离示意两个 Lock 的子类对象，每一个 lock 的 Condition 之间能够相互操作，对于两个
锁之间的 Condition，比方，x 和 Q，就没有间接的关系了
好了，这篇文章次要阐明下 Lock+Condition 形式来取代 synchronized, 心愿对大家有所帮忙。
