1. package inter;
   
2. 
   
3. import java.util.concurrent.Executors;
   
4. import java.util.concurrent.ExecutorService;
   
5. import java.util.concurrent.locks.Lock;
   
6. import java.util.concurrent.locks.ReentrantLock;
   
7. import java.util.concurrent.locks.Condition;
   
8. 
   
9. public class ThreadTest3 {
   
10.         private static Lock lock = new ReentrantLock();
    
11.         private static Condition subThreadCondition = lock.newCondition();
    
12.         private static boolean bBhouldSubThread = false;
    
13. 
    
14.         public static void main(String[] args) {
    
15.                 ExecutorService threadPool = Executors.newFixedThreadPool(2);
    
16.                 threadPool.execute(new Runnable() {
    
17.                         public void run() {
    
18.                                 for (int i = 0; i < 5; i++) {
    
19.                                         lock.lock();
    
20.                                         try {
    
21.                                                 if (!bBhouldSubThread){//不应该应该执行子线程
    
22.                                                         subThreadCondition.await();
    
23.                                                         System.out.println("我开始执行了"+bBhouldSubThread);
    
24.                                                 }
    
25.                                                 for (int j = 0; j < 2; j++) {
    
26.                                                         System.out.println("我开始执行了2");
    
27.                                                         System.out.println(Thread.currentThread().getName()
    
28.                                                                         + ",j=" + j);
    
29.                                                 }
    
30.                                                 bBhouldSubThread = false;
    
31.                                                 subThreadCondition.signal();
    
32.                                         } catch (Exception e) {
    
33.                                         } finally {
    
34.                                                 lock.unlock();
    
35.                                         }
    
36.                                 }
    
37.                         }
    
38. 
    
39.                 });
    
40.                 threadPool.shutdown();//在完成已提交的任务后关闭服务，不再接受新任务
    
41.                 for (int i = 0; i < 5; i++) {
    
42.                         System.out.println("我啊啊啊啊啊啊啊");
    
43.                         lock.lock();
    
44.                         try {
    
45.                                 if (bBhouldSubThread){//应该执行子线程
    
46.                                         System.out.println("我啊啊啊啊啊啊啊3"+bBhouldSubThread);
    
47.                                         subThreadCondition.await();
    
48.                                 }
    
49.                                 for (int j = 0; j < 10; j++) {
    
50.                                         System.out.println(Thread.currentThread().getName() + ",i="
    
51.                                                         + j);
    
52.                                 }
    
53.                                 bBhouldSubThread = true;
    
54.                                 subThreadCondition.signal();
    
55.                         } catch (Exception e) {
    
56.                         } finally {
    
57.                                 System.out.println("我啊啊啊啊啊啊啊2");
    
58.                                 lock.unlock();
    
59.                         }
    
60.                 }
    
61.         }
    
62. }

复制代码

这是主线程和子线程轮番打印数字的程序，我想问一下，是不是subThreadCondition.await();这句之后停在哪儿，然后调用subThreadCondition.signal();之后就在subThreadCondition.await();这句之后继续执行。例如停在了红色的这一句System.out.println("我啊啊啊啊啊啊啊3"+bBhouldSubThread);，那么执行了signal之后会继续执行下面的for循环？还有个问题，只有一个condition，        subThreadCondition.await();这句被调用后，那么到底谁等待啊，这个是怎么控制的，可以说下原理吗？谢谢更多

0

我啊啊啊啊啊啊啊3

Thanks,我是来刷技术分的·····以前遇到的问题直接粘过来了。嘿嘿。不过还是谢谢了。
问题中开始没明白，这样的多线程中本身停在哪被唤醒之后就还是在原来的语句后继续执行。还有一个问题是
其实虽然是用的同一个condition，但是condition.signal唤醒的是等待中的线程。

为什么没人呢