先把代码贴出来

1. package cn.ywl.extendsdemos;
   
2. 
   
3. import java.util.concurrent.locks.Condition;
   
4. import java.util.concurrent.locks.Lock;
   
5. import java.util.concurrent.locks.ReentrantLock;
   
6. 
   
7. public class LockDemo {
   
8. 
   
9.         public static void main(String[] args) {
   
10. 
    
11.                 Lockc ck = new Lockc();
    
12.                 producer p = new producer(ck);
    
13.                 consumer c = new consumer(ck);
    
14. 
    
15.                 Thread t1 = new Thread(p);
    
16.                 Thread t2 = new Thread(p);
    
17.                 Thread t3 = new Thread(c);
    
18.                 Thread t4 = new Thread(c);
    
19. 
    
20.                 t4.start();
    
21.                 t2.start();
    
22.                 t3.start();
    
23.                 t1.start();
    
24.         }
    
25. 
    
26. }
    
27. 
    
28. class Lockc {
    
29. 
    
30.         private String name;
    
31.         public int cuu = 1;
    
32.         private boolean o = false;
    
33. 
    
34.         Lock kk = new ReentrantLock();
    
35.         Condition ll_1 = kk.newCondition();
    
36.         Condition ll_2 = kk.newCondition();
    
37. 
    
38.         public void set(String name) throws InterruptedException {
    
39.                
    
40.                 System.out.println(Thread.currentThread().getName()+"set run!!");
    
41.                
    
42.                 kk.lock();               
    
43.                
    
44.                 while (o)
    
45.                         try {
    
46.                                 System.out.println("set ..... try");
    
47.                                 ll_1.await(); // t1 t2
    
48.                                 this.name = name + "....." + cuu++;
    
49. 
    
50.                                 System.out.println("生产者...................." + this.name+ "..........");
    
51.                                 o = true;
    
52.                                 ll_2.signal();
    
53.                         } finally {
    
54.                                 System.out.println("set .....finally!");
    
55.                                 kk.unlock();
    
56.                         }
    
57.                 System.out.println("set over!!!");
    
58.         }
    
59. 
    
60.         public void out() throws InterruptedException {                        //如果操作这段代码的线程第一个抢到CPU，那么这里就会执行一次
    
61.                
    
62.                 System.out.println("out run!!!");                               
    
63.                
    
64.                 kk.lock();                                                                                                               
    
65.                                                
    
66.                 while (!o)
    
67.                         try {
    
68.                                 System.out.println(".....");
    
69.                                 ll_2.await(); // t3 t4                                                        //!o = true，线程直接 wait了。
    
70.                                 System.out.println("消费者" + "...........");
    
71.                                 o = false;
    
72.                                 ll_1.signal();
    
73.                         } finally {
    
74.                                 System.out.println("unlock!!!");
    
75.                                 kk.unlock();                                                                        //能执行到try里面，当然也能执行到finally里面
    
76.                         }
    
77.                 System.out.println("set over!!!");
    
78.         }
    
79. }
    
80. 
    
81. class producer implements Runnable {
    
82.         private Lockc lo;
    
83. 
    
84.         producer(Lockc lo) {
    
85.                 this.lo = lo;
    
86.         }
    
87. 
    
88.         public void run() {
    
89. 
    
90.                 while (true) {
    
91.                        
    
92.                         try {
    
93.                                 Thread.sleep(1000);
    
94.                         } catch (InterruptedException e1) {
    
95.                                 e1.printStackTrace();
    
96.                         }
    
97.                         // if(lo.cuu>0)
    
98.                         try {
    
99.                                 lo.set("++商品++");
    
100.                         } catch (InterruptedException e) {
     
101.                                 e.printStackTrace();
     
102.                         }
     
103.                 }
     
104.         }
     
105. }
     
106. 
     
107. class consumer implements Runnable {
     
108.         private Lockc lo;
     
109. 
     
110.         consumer(Lockc lo) {
     
111.                 this.lo = lo;
     
112.         }
     
113. 
     
114.         public void run() {
     
115. 
     
116.                 while (true) {
     
117.                         try {
     
118.                                 Thread.sleep(1000);
     
119.                         } catch (InterruptedException e1) {
     
120.                                 e1.printStackTrace();
     
121.                         }
     
122.                         try {
     
123.                                 lo.out();
     
124.                         } catch (InterruptedException e) {
     
125.                                 e.printStackTrace();
     
126.                         }
     
127.                 }
     
128.         }
     
129. 
     
130. }
     
131. /*
     
132. 运行几秒的结果：
     
133. out run!!!
     
134. .....
     
135. Thread-1set run!!
     
136. set over!!!
     
137. out run!!!
     
138. Thread-0set run!!
     
139. Thread-1set run!!
     
140. set over!!!
     
141. Thread-1set run!!
     
142. set over!!!
     
143. Thread-1set run!!
     
144. set over!!!
     
145. */

复制代码

关于lock()方法，API中有这样一句：如果锁不可用，出于线程调度目的，将禁用当前线程，并且在获得锁之前，该线程将一直处于休眠状态。

在我这段代码中，第一个拿到kk锁的是消费者线程，为什么生产者线程还可以使用kk.lock();?

难道API中说的禁用当前线程是指的前面获取kk锁的消费者线程？不应该啊。

求解释........

{:soso_e150:}求解释.......

帖子马上要沉了。。。自己顶起来。求解释{:soso_e149:}

多线程通信的问题，当一个线程处于睡眠或wait状态时，就会放弃执行资格，同时就释放锁，那么醒着的线程就能拿到锁，并执行了。