如何使用Lock取代synchronized



  如何使用Lock取代synchronized

  在多线程中,1.5版本之前,我们都使用同步代码块或者同步方法来解决线程安全问题

  比如:

  同步代码块

  synchronized(锁对象){

  功能代码;

  }

  同步方法

  public synchronized void test(){

  功能代码;

  }

  在1.5版本,在java的工具类包中,java.util.concurrent.locks 中,推出了最新的

  解决线程安全的方法,就是Lock+Condition的方式,

  那这两种方式之间的关系和区别是什么呢?

  加入对于线程常见的生产者消费者模式,我们使用两种方式实现,来看看他们的区别:

  第一种,使用synchronized

  我们完成一个男人挣钱女人花的例子

  需求是如果没钱,男人线程挣一次钱,等待,然后唤醒女人去花钱,花完钱,等待,唤醒

  男人去挣钱,一直循环这个过程,将男人线程看做生产线程,女人线程看做消费线程。

  代码如下:

  //首先完成共享数据

  class Person{

  String name;

  boolean isMoney=true;

  //挣钱

  public void zhengQian(){

  synchronized(this){

  while(!isMoney){

  try{wait();}catch(Exception e){}

  }

  name=男人;

  System.out.println(Thread.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,希望对大家有所帮助。

  如何使用Lock取代synchronized

  在多线程中,1.5版本之前,我们都使用同步代码块或者同步方法来解决线程安全问题

  比如:

  同步代码块

  synchronized(锁对象){

  功能代码;

  }

  同步方法

  public synchronized void test(){

  功能代码;

  }

  在1.5版本,在java的工具类包中,java.util.concurrent.locks 中,推出了最新的

  解决线程安全的方法,就是Lock+Condition的方式,

  那这两种方式之间的关系和区别是什么呢?

  加入对于线程常见的生产者消费者模式,我们使用两种方式实现,来看看他们的区别:

  第一种,使用synchronized

  我们完成一个男人挣钱女人花的例子

  需求是如果没钱,男人线程挣一次钱,等待,然后唤醒女人去花钱,花完钱,等待,唤醒

  男人去挣钱,一直循环这个过程,将男人线程看做生产线程,女人线程看做消费线程。

  代码如下:

  //首先完成共享数据

  class Person{

  String name;

  boolean isMoney=true;

  //挣钱

  public void zhengQian(){

  synchronized(this){

  while(!isMoney){

  try{wait();}catch(Exception e){}

  }

  name=男人;

  System.out.println(Thread.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,希望对大家有所帮助。

阅读更多
个人分类: 个人技术分享
上一篇Java中的位移运算符
下一篇技术分享:JAVA反射
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭