黑马程序员技术交流社区

标题: 线程通信？ [打印本页]
作者: 全海波    时间: 2012-8-2 19:48
标题: 线程通信？
本帖最后由 全海波 于 2012-8-4 09:37 编辑
  1. class ProducerConsumerDemo
  2. {
  3. public static void main(String[] args)
  4. {
  5. Resource r = new Resource();

  7. Producer pro = new Producer(r);
  8. Consumer con = new Consumer(r);

  10. Thread t1 = new Thread(pro);
  11. Thread t2 = new Thread(pro);
  12. Thread t3 = new Thread(con);
  13. Thread t4 = new Thread(con);

  15. t1.start();
  16. t2.start();
  17. t3.start();
  18. t4.start();

  20. }
  21. }

  23. class Resource
  24. {
  25. private String name;
  26. private int count = 1;
  27. private boolean flag = false;
  28. // t1 t2
  29. public synchronized void set(String name)
  30. {
  31. while(flag)
  32. try{this.wait();}catch(Exception e){}
  33. this.name = name+"--"+count++;

  35. System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
  36. flag = true;
  37. this.notifyAll();
  38. }

  40. public synchronized void out()
  41. {
  42. while(!flag)
  43. try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
  44. System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
  45. flag = false;
  46. this.notifyAll();
  47. }
  48. }

  50. class Producer implements Runnable
  51. {
  52. private Resource res;

  54. Producer(Resource res)
  55. {
  56. this.res = res;
  57. }
  58. public void run()
  59. {
  60. while(true)
  61. {
  62. res.set("+商品+");
  63. }
  64. }
  65. }

  67. class Consumer implements Runnable
  68. {
  69. private Resource res;

  71. Consumer(Resource res)
  72. {
  73. this.res = res;
  74. }
  75. public void run()
  76. {
  77. while(true)
  78. {
  79. res.out();
  80. }
  81. }
  82. }
复制代码
  1. import java.util.concurrent.locks.*;

  3. class ProducerConsumerDemo2
  4. {
  5. public static void main(String[] args)
  6. {
  7. Resource r = new Resource();

  9. Producer pro = new Producer(r);
  10. Consumer con = new Consumer(r);

  12. Thread t1 = new Thread(pro);
  13. Thread t2 = new Thread(pro);
  14. Thread t3 = new Thread(con);
  15. Thread t4 = new Thread(con);

  17. t1.start();
  18. t2.start();
  19. t3.start();
  20. t4.start();

  22.    }
  23. }
  24. class Resource
  25. {
  26. private String name;
  27. private int count = 1;
  28. private boolean flag = false;
  29. // t1 t2
  30. private Lock lock = new ReentrantLock();

  32. private Condition condition_pro = lock.newCondition();
  33. private Condition condition_con = lock.newCondition();



  37. public void set(String name)throws InterruptedException
  38. {
  39. lock.lock();
  40. try
  41. {
  42. while(flag)
  43. condition_pro.await();//t1,t2
  44. this.name = name+"--"+count++;

  46. System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
  47. flag = true;
  48. condition_con.signal();
  49. }
  50. finally
  51. {
  52. lock.unlock();
  53. }
  54. }
  55. public void out()throws InterruptedException
  56. {
  57. lock.lock();
  58. try
  59. {
  60. while(!flag)
  61. condition_con.await();
  62. System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
  63. flag = false;
  64. condition_pro.signal();
  65. }
  66. finally
  67. {
  68. lock.unlock();
  69. }

  71. }
  72. }

  74. class Producer implements Runnable
  75. {
  76. private Resource res;

  78. Producer(Resource res)
  79. {
  80. this.res = res;
  81. }
  82. public void run()
  83. {
  84. while(true)
  85. {
  86. try
  87. {
  88. res.set("+商品+");
  89. }
  90. catch (InterruptedException e)
  91. {
  92. }

  94. }
  95. }
  96. }

  98. class Consumer implements Runnable
  99. {
  100. private Resource res;

  102. Consumer(Resource res)
  103. {
  104. this.res = res;
  105. }
  106. public void run()
  107. {
  108. while(true)
  109. {
  110. try
  111. {
  112. res.out();
  113. }
  114. catch (InterruptedException e)
  115. {
  116. }
  117. }
  118. }
  119. }
复制代码
问，以上两者的区别？优势在和地方？
作者: 王程    时间: 2012-8-3 20:44
synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定，但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到finally{}中。
在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态。
这是刚才查到的



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