黑马程序员技术交流社区

标题: 关于同步的问题 [打印本页]
作者: JarryHorse    时间: 2015-4-26 22:05
标题: 关于同步的问题
Lock类可以实现锁的功能，那么问题来了，synchronized可以指定锁对象，如果说Lock本身就是锁对象的话，在线程间通讯的时候，为什么使用同一个Lock对象lock两个方法内的代码，但这两个代码是可以同时执行的。
  1. /*
  2. 需求：演示Lock类和线程间通讯
  3. */

  5. import java.util.concurrent.locks.*;

  7. //封装了主函数的类
  8. class  ThreadDemo
  9. {
  10.         //主函数
  11.         public static void main(String[] args)
  12.         {
  13.                 //创建Runnable子类对象，在构造函数中传入
  14.                 Data data = new Data();

  16.                 //创建两个线程对象，在构造函数传入同一个Runnable子类对象
  17.                 new Thread(new TrueData(data)).start();
  18.                 new Thread(new FalseData(data)).start();

  20.         }
  21. }
  22. //用实现Runnable接口的方法创建类
  23. class TrueData implements Runnable
  24. {

  26.         private Data data;

  28.         TrueData(Data data)
  29.         {
  30.                 this.data = data;
  31.         }
  32.        
  33.         public void run()
  34.         {
  35.                 data.on();
  36.         }
  37. }
  38. //用实现Runnable接口的方法创建类
  39. class FalseData implements Runnable
  40. {
  41.         private Data data;

  43.         FalseData(Data data)
  44.         {
  45.                 this.data = data;
  46.         }

  48.         public void run()
  49.         {
  50.                 data.off();
  51.         }
  52. }
  53. class Data
  54. {
  55.         private int num = 1;
  56.         private boolean logic = true;

  58.         //定义两个同步代码块的锁对象
  59.         private Lock lock = new ReentrantLock();
  60.         private Condition cona = lock.newCondition();
  61.         private Condition conb = lock.newCondition();



  65.         public void on()
  66.         {
  67.                 while(true)
  68.                 {
  69.                         try
  70.                         {
  71.                                 lock.lock();
  72.                                 if (logic)
  73.                                 {
  74.                                         cona.await();
  75.                                 }
  76.                                 num = 1;
  77.                                 logic = true;

  79.                                 //打印语句
  80.                                 System.out.println("Logic on..."+"num:"+num+" logic:"+logic);
  81.                                                
  82.                                 conb.signal();
  83.                         }
  84.                         catch (InterruptedException e)
  85.                         {
  86.                                 e.printStackTrace();
  87.                         }
  88.                         finally
  89.                         {
  90.                                 lock.unlock();
  91.                         }
  92.                 }
  93.         }
  94.         public void off()
  95.         {
  96.                 while(true)
  97.                 {
  98.                         try
  99.                         {
  100.                                 lock.lock();
  101.                                         if(!logic)
  102.                                                 conb.await();
  103.                                         num = 0;
  104.                                         logic=false;

  106.                                         //打印语句
  107.                                         System.out.println("Logic off......"+"num:"+num+" logic:"+logic);
  108.                                                
  109.                                         cona.signal();
  110.                                
  111.                         }
  112.                         catch (InterruptedException e)
  113.                         {
  114.                                 e.printStackTrace();
  115.                         }
  116.                         finally
  117.                         {
  118.                                 lock.unlock();
  119.                         }
  120.                 }
  121.         }
  122. }
复制代码

像这样，线程在同步中wait了，为什么另一个线程可以执行同步内的代码，难道当前线程wait的时候会释放此锁么？看API中貌似没有这样的描述，困惑，请大神解答



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2