在多线程中,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,心愿对大家有所帮忙。