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. }[code]import java.util.concurrent.locks.*;
    
83. 
    
84. class ProducerConsumerDemo2
    
85. {
    
86. public static void main(String[] args)
    
87. {
    
88. Resource r = new Resource();
    
89. 
    
90. Producer pro = new Producer(r);
    
91. Consumer con = new Consumer(r);
    
92. 
    
93. Thread t1 = new Thread(pro);
    
94. Thread t2 = new Thread(pro);
    
95. Thread t3 = new Thread(con);
    
96. Thread t4 = new Thread(con);
    
97. 
    
98. t1.start();
    
99. t2.start();
    
100. t3.start();
     
101. t4.start();
     
102. 
     
103.    }
     
104. }
     
105. class Resource
     
106. {
     
107. private String name;
     
108. private int count = 1;
     
109. private boolean flag = false;
     
110. // t1 t2
     
111. private Lock lock = new ReentrantLock();
     
112. 
     
113. private Condition condition_pro = lock.newCondition();
     
114. private Condition condition_con = lock.newCondition();
     
115. 
     
116. 
     
117. 
     
118. public void set(String name)throws InterruptedException
     
119. {
     
120. lock.lock();
     
121. try
     
122. {
     
123. while(flag)
     
124. condition_pro.await();//t1,t2
     
125. this.name = name+"--"+count++;
     
126. 
     
127. System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
     
128. flag = true;
     
129. condition_con.signal();
     
130. }
     
131. finally
     
132. {
     
133. lock.unlock();
     
134. }
     
135. }
     
136. public void out()throws InterruptedException
     
137. {
     
138. lock.lock();
     
139. try
     
140. {
     
141. while(!flag)
     
142. condition_con.await();
     
143. System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
     
144. flag = false;
     
145. condition_pro.signal();
     
146. }
     
147. finally
     
148. {
     
149. lock.unlock();
     
150. }
     
151. 
     
152. }
     
153. }
     
154. 
     
155. class Producer implements Runnable
     
156. {
     
157. private Resource res;
     
158. 
     
159. Producer(Resource res)
     
160. {
     
161. this.res = res;
     
162. }
     
163. public void run()
     
164. {
     
165. while(true)
     
166. {
     
167. try
     
168. {
     
169. res.set("+商品+");
     
170. }
     
171. catch (InterruptedException e)
     
172. {
     
173. }
     
174. 
     
175. }
     
176. }
     
177. }
     
178. 
     
179. class Consumer implements Runnable
     
180. {
     
181. private Resource res;
     
182. 
     
183. Consumer(Resource res)
     
184. {
     
185. this.res = res;
     
186. }
     
187. public void run()
     
188. {
     
189. while(true)
     
190. {
     
191. try
     
192. {
     
193. res.out();
     
194. }
     
195. catch (InterruptedException e)
     
196. {
     
197. }
     
198. }
     
199. }
     
200. }

复制代码

[/code]
问这两者有什么区别？第二者的优势何在？

看来楼主是想问lock和synchronized的区别了
好长的两段代码，而且还写在了一块

首先synchronized是在JVM层面上实现的
在代码执行时出现异常，JVM会自动释放锁定
但是使用Lock则不行
lock是通过代码实现的
要保证锁定一定会被释放，就必须将unLock()放到finally{}中

其次使用 synchronized ，如果T不释放，T1将一直等下去，不能被中断
如果 使用lock，如果T不释放，可以使T1在等待了足够长的时间以后，中断等待
这就致使在资源竞争不是很激烈的情况下，Synchronized的性能要优于lock
但是在资源竞争很激烈的情况下，Synchronized的性能会成倍下降，lock却性能能维持常态
希望对你有所帮助。。。