黑马程序员技术交流社区

标题: 毕老师多线程LOCK锁中的问题 [打印本页]
作者: 支天歌    时间: 2014-1-9 14:39
标题: 毕老师多线程LOCK锁中的问题
照着视频敲了好几遍，翻来覆去的找还是没有找到问题所在，每次输出都是打印一两次就停止了。

代码如下:

  1. package 多线程;

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

  5. class Resource
  6. {
  7.         private String name;
  8.         private int count = 1;
  9.         private boolean flag = false;
  10.        
  11.         //重点变化，使用Lock代替线程同步
  12.         private Lock lock = new ReentrantLock();
  13.         private Condition condition_pro = lock.newCondition();
  14.         private Condition condition_con = lock.newCondition();
  15.        
  16.         public synchronized void set(String name)throws InterruptedException
  17.         {
  18.                 lock.lock();
  19.                
  20.                 //全部唤醒，通过循环控制
  21.                 try
  22.                 {
  23.                 while(flag)
  24.                         condition_pro.await();
  25.                
  26.                 this.name = name+"--"+count++;
  27.                
  28.                 System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
  29.                 flag = true;
  30.                
  31.                 condition_con.signal();
  32.                 }
  33.                 finally
  34.                 {
  35.                         lock.unlock();

  37.                 }
  38.                
  39.         }
  40.        
  41.         public synchronized void out() throws InterruptedException
  42.         {
  43.                 lock.lock();
  44.                 //全部唤醒，通过循环控制
  45.                 try
  46.                 {
  47.                 while(!flag)
  48.                         condition_con.await();       
  49.                
  50.                 System.out.println(Thread.currentThread().getName()+"---消费者---"+this.name);
  51.                 flag = false;
  52.                
  53.                 condition_pro.signal();
  54.                 }
  55.                 finally
  56.                 {
  57.                         lock.unlock();

  59.                 }
  60.         }
  61. }

  63. class Producer implements Runnable
  64. {
  65.         private Resource res;
  66.         Producer(Resource res)
  67.         {
  68.                 this.res = res;
  69.         }
  70.         public void run()
  71.         {
  72.                 while(true)
  73.                 {
  74.                         try {
  75.                                 res.set("-商品-");
  76.                         } catch (InterruptedException e) {
  77.                                 //e.printStackTrace();
  78.                         }
  79.                 }
  80.         }
  81. }

  83. class Consumer implements Runnable
  84. {
  85.         private Resource res;
  86.         Consumer(Resource res)
  87.         {
  88.                 this.res = res;
  89.         }
  90.         public void run()
  91.         {
  92.                 while(true)
  93.                 {
  94.                         try {
  95.                                 res.out();
  96.                         } catch (InterruptedException e) {
  97.                                 //e.printStackTrace();
  98.                         }
  99.                 }
  100.         }
  101. }
  102. public class Example9 {
  103.        
  104.         public static void main(String[] args) {
  105.                 Resource r = new Resource();
  106.                
  107.                 Producer pro = new Producer(r);
  108.                 Consumer con = new Consumer(r);
  109.                
  110.                 Thread t1 = new Thread(pro);
  111.                 Thread t2 = new Thread(pro);
  112.                 Thread t3 = new Thread(con);
  113.                 Thread t4 = new Thread(con);
  114.                
  115.                 t1.start();
  116.                 t2.start();
  117.                 t3.start();
  118.                 t4.start();
  119.                
  120.                
  121.         }

  123. }
复制代码



作者: 贺奕凯    时间: 2014-1-9 14:55
去掉synchronized

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

  3. class Resource
  4. {
  5.         private String name;
  6.         private int count = 1;
  7.         private boolean flag = false;
  8.        
  9.         //重点变化，使用Lock代替线程同步
  10.         private Lock lock = new ReentrantLock();
  11.        
  12.         //通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者。
  13.         private Condition condition_pro = lock.newCondition();
  14.         private Condition condition_con = lock.newCondition();
  15.        
  16.         public void set(String name)throws InterruptedException
  17.         {
  18.                 lock.lock();
  19.                
  20.                 //全部唤醒，通过循环控制
  21.                 try
  22.                 {
  23.                         while(flag)
  24.                                 condition_pro.await();
  25.                        
  26.                         this.name = name+"--"+count++;
  27.                        
  28.                         System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
  29.                         flag = true;
  30.                        
  31.                         condition_con.signal();
  32.                 }
  33.                 finally
  34.                 {
  35.                         lock.unlock();

  37.                 }
  38.                
  39.         }
  40.        
  41.         public void out() throws InterruptedException
  42.         {
  43.                 lock.lock();
  44.                 //全部唤醒，通过循环控制
  45.                 try
  46.                 {
  47.                 while(!flag)
  48.                         condition_con.await();       
  49.                
  50.                 System.out.println(Thread.currentThread().getName()+"---消费者---"+this.name);
  51.                 flag = false;
  52.                
  53.                 condition_pro.signal();
  54.                 }
  55.                 finally
  56.                 {
  57.                         lock.unlock();

  59.                 }
  60.         }
  61. }

  63. class Producer implements Runnable
  64. {
  65.         private Resource res;
  66.         Producer(Resource res)
  67.         {
  68.                 this.res = res;
  69.         }
  70.         public void run()
  71.         {
  72.                 while(true)
  73.                 {
  74.                         try {
  75.                                 res.set("-商品-");
  76.                         } catch (InterruptedException e) {
  77.                                 //e.printStackTrace();
  78.                         }
  79.                 }
  80.         }
  81. }

  83. class Consumer implements Runnable
  84. {
  85.         private Resource res;
  86.         Consumer(Resource res)
  87.         {
  88.                 this.res = res;
  89.         }
  90.         public void run()
  91.         {
  92.                 while(true)
  93.                 {
  94.                         try {
  95.                                 res.out();
  96.                         } catch (InterruptedException e) {
  97.                                 //e.printStackTrace();
  98.                         }
  99.                 }
  100.         }
  101. }
  102. public class Example9 {
  103.        
  104.         public static void main(String[] args) {
  105.                 Resource r = new Resource();
  106.                
  107.                 Producer pro = new Producer(r);
  108.                 Consumer con = new Consumer(r);
  109.                
  110.                 Thread t1 = new Thread(pro);
  111.                 Thread t2 = new Thread(pro);
  112.                 Thread t3 = new Thread(con);
  113.                 Thread t4 = new Thread(con);
  114.                
  115.                 t1.start();
  116.                 t2.start();
  117.                 t3.start();
  118.                 t4.start();
  119.                
  120.                
  121.         }

  123. }
复制代码
作者: 伍艳雄    时间: 2014-1-9 18:11
  1. package 多线程;

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

  5. class Resource
  6. {
  7.         private String name;
  8.         private int count = 1;
  9.         private boolean flag = false;
  10.         
  11.         //重点变化，使用Lock代替线程同步
  12.         private Lock lock = new ReentrantLock();
  13.         private Condition condition_pro = lock.newCondition();
  14.         private Condition condition_con = lock.newCondition();
  15.         
  16.         public void set(String name)throws InterruptedException //把这里的synchronized 锁去掉.
  17.         {
  18.                 lock.lock();
  19.                
  20.                 //全部唤醒，通过循环控制
  21.                 try
  22.                 {
  23.                 while(flag)
  24.                         condition_pro.await();
  25.                
  26.                 this.name = name+"--"+count++;
  27.                
  28.                 System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
  29.                 flag = true;
  30.                
  31.                 condition_con.signal();
  32.                 }
  33.                 finally
  34.                 {
  35.                         lock.unlock();

  37.                 }
  38.                
  39.         }
  40.         
  41.         public void out() throws InterruptedException //这里的锁synchronized 也要去掉.
  42.         {
  43.                 lock.lock();
  44.                 //全部唤醒，通过循环控制
  45.                 try
  46.                 {
  47.                 while(!flag)
  48.                         condition_con.await();        
  49.                
  50.                 System.out.println(Thread.currentThread().getName()+"---消费者---"+this.name);
  51.                 flag = false;
  52.                
  53.                 condition_pro.signal();
  54.                 }
  55.                 finally
  56.                 {
  57.                         lock.unlock();

  59.                 }
  60.         }
  61. }

  63. class Producer implements Runnable
  64. {
  65.         private Resource res;
  66.         Producer(Resource res)
  67.         {
  68.                 this.res = res;
  69.         }
  70.         public void run()
  71.         {
  72.                 while(true)
  73.                 {
  74.                         try {
  75.                                 res.set("-商品-");
  76.                         } catch (InterruptedException e) {
  77.                                 //e.printStackTrace();
  78.                         }
  79.                 }
  80.         }
  81. }

  83. class Consumer implements Runnable
  84. {
  85.         private Resource res;
  86.         Consumer(Resource res)
  87.         {
  88.                 this.res = res;
  89.         }
  90.         public void run()
  91.         {
  92.                 while(true)
  93.                 {
  94.                         try {
  95.                                 res.out();
  96.                         } catch (InterruptedException e) {
  97.                                 //e.printStackTrace();
  98.                         }
  99.                 }
  100.         }
  101. }
  102. public class Example9 {
  103.         
  104.         public static void main(String[] args) {
  105.                 Resource r = new Resource();
  106.                
  107.                 Producer pro = new Producer(r);
  108.                 Consumer con = new Consumer(r);
  109.                
  110.                 Thread t1 = new Thread(pro);
  111.                 Thread t2 = new Thread(pro);
  112.                 Thread t3 = new Thread(con);
  113.                 Thread t4 = new Thread(con);
  114.                
  115.                 t1.start();
  116.                 t2.start();
  117.                 t3.start();
  118.                 t4.start();
  119.                
  120.                
  121.         }

  123. }
复制代码


把16行,和41行的synchronized 去掉.



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