1. class ProducerConsumerDemo
   
2. {
   
3. public static void main(String[] args)
   
4. {
   
5. Resource r = new Resource();
   
6. 
   
7. Producer pro = new Producer(r);
   
8. Consumer con = new Consumer(r);
   
9. 
   
10. Thread t1 = new Thread(pro);
    
11. Thread t2 = new Thread(pro);
    
12. Thread t3 = new Thread(con);
    
13. Thread t4 = new Thread(con);
    
14. 
    
15. t1.start();
    
16. t2.start();
    
17. t3.start();
    
18. t4.start();
    
19. 
    
20. }
    
21. }
    
22. 
    
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++;
    
34. 
    
35. System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
    
36. flag = true;
    
37. this.notifyAll();
    
38. }
    
39. 
    
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. }
    
49. 
    
50. class Producer implements Runnable
    
51. {
    
52. private Resource res;
    
53. 
    
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. }
    
66. 
    
67. class Consumer implements Runnable
    
68. {
    
69. private Resource res;
    
70. 
    
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.*;
   
2. 
   
3. class ProducerConsumerDemo2
   
4. {
   
5. public static void main(String[] args)
   
6. {
   
7. Resource r = new Resource();
   
8. 
   
9. Producer pro = new Producer(r);
   
10. Consumer con = new Consumer(r);
    
11. 
    
12. Thread t1 = new Thread(pro);
    
13. Thread t2 = new Thread(pro);
    
14. Thread t3 = new Thread(con);
    
15. Thread t4 = new Thread(con);
    
16. 
    
17. t1.start();
    
18. t2.start();
    
19. t3.start();
    
20. t4.start();
    
21. 
    
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();
    
31. 
    
32. private Condition condition_pro = lock.newCondition();
    
33. private Condition condition_con = lock.newCondition();
    
34. 
    
35. 
    
36. 
    
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++;
    
45. 
    
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. }
    
70. 
    
71. }
    
72. }
    
73. 
    
74. class Producer implements Runnable
    
75. {
    
76. private Resource res;
    
77. 
    
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. }
    
93. 
    
94. }
    
95. }
    
96. }
    
97. 
    
98. class Consumer implements Runnable
    
99. {
    
100. private Resource res;
     
101. 
     
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. }
     

复制代码

问，以上两者的区别？优势在和地方？

synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定，但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到finally{}中。
在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态。
这是刚才查到的