一个线程a在 启动一组线程后先执行一段代码wait后，这组线程再执行

Question

一个线程a 启动一组由线程池启动的runnable线程（约100个），
exe = Executors.newFixedThreadPool(POOL_SIZE);// 
// start the thread execution
for (int j = 0; j < NumOfLp; j++) {
exe.execute(LP.getInstance(j));

System.out.println("we r creating the " + j + "LP");
}
}但是要求主线程a要首先执行
其中的代码
while(GlobalControl.isEnd.booleanValue()==false)
{

synchronized (GlobalControl.isEnd) { try {
GlobalControl.isEnd.wait();//此处表示停止所有线程池中的runnable
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}

然后，各个runnable线程（约100个）才能够开始执行，

这个顺序的原因是他们的代码中有
synchronized (GlobalControl.isEnd) {
GlobalControl.isEnd=true;
GlobalControl.isEnd.notify();
}
用于在条件满足时唤醒主线程。而wait又是无状态的，如果不让主线程先执行wait，有可能notify了，wait代码还没执行

难度在于，要求主线程wait后，才能让线程池中的大量线程同步开始run，高手请出招:)

Answer 1

此回复为自动发出,仅用于显示而已，并无任何其他特殊作用
楼主【denverbenjamin2000】截止到2008-07-10 18:34:36的历史汇总数据(不包括此帖)：
发帖的总数量:16                       发帖的总分数:1340                     每贴平均分数:83                       
回帖的总数量:25                       得分贴总数量:2                        回帖的得分率:8%                       
结贴的总数量:11                       结贴的总分数:870                      
无满意结贴数:0                        无满意结贴分:0                        
未结的帖子数:5                        未结的总分数:470                      
结贴的百分比:68.75 %               结分的百分比:64.93 %                  
无满意结贴率:0.00  %               无满意结分率:0.00  %                  
楼主加油

Answer 2

强制睡眠太笨，
想另外开一个线程，在
        try {
            // Thread B 加入 Thread A
            主线程名.join();
        } 
        catch(InterruptedException e) { 
            e.printStackTrace(); 
        } 
之后启动线程池内线程执行吧，又不知道怎么得到对主线程的引用郁闷

Answer 3

是否问题出在wait和notify是在一个静态变量
public static Boolean isEnd=false;上进行的呢？我通过睡眠方法保序后，报出
Exception in thread "pool-1-thread-20" java.lang.IllegalMonitorStateException
at java.lang.Object.notify(Native Method)
at thread1.ParaNull.LogicalProcess.run(LogicalProcess.java:367)
at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:885)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:907)
at java.lang.Thread.run(Thread.java:619)
错误

Answer 4

3楼问题已经解决，报IllegalMonitorStateException的原因是        synchronized (GlobalControl.isEnd) {
            GlobalControl.isEnd=true;
            GlobalControl.isEnd.notify();
        }
中，GlobalControl.isEnd=true;将使得GlobalControl.isEnd指向一个与
synchronized (GlobalControl.isEnd) 截然不同的对象，当然出问题了。呵呵。
原来的问题继续。。

Answer 5

不明白楼主的意思,
Thread类,查一下API,每一个线程都会有getState()方法,它可以得到线程的当前状态.楼主要明白,Executors.newFixedThreadPool(POOL_SIZE);这个调用只是创建了一个线程池,但是,里面的线程都没有执行(或者说,没有进入run方法)
只有调用了exe.execute(LP.getInstance(j));方法,线程池中的线程,才能够进入run方法.不明白主线程wait的目的是什么.一般来讲,当主线程任务很多或者任务量很大的时候才会想到使用线程池.
这个时候,要弄明白,主线程的任务和线程池中线程的任务之间的关系.
一般来讲,主线程将自己的多余任务交由线程处理以后,就不再管了.也就是说,不再发生关系了.
但是也有,主线程,需要处理,线程池中线程的处理结果信息.在这种情况下,我的处理思路是:
0.编写线程池的处理类的代码,该类在创建对象时,传入一个处理结果的对象引用(将处理结果传入对象里面).注意线程安全的问题.
1.主线程先创建一个线程池pool=Executors.newFixedThreadPool(POOL_SIZE);
2.创建线程池处理类的对象,将处理结果对象传入.
3.主线程将处理内容提交到线程池,pool.execute(Runnable runnable);
4.主线程不进行wait,而维护那个处理结果对象,循环判断结果对象中线程池的处理结果是否已经已经完成(每次循环都sleep),如果完成,跳出循环.
5.主线程 处理结果对象,将线程池的运行结果进行处理.
不知道是否能给楼主一个启发.

Answer 6

先public static Object locker = new Object();让你的“runnable线程”的 run 方法public void run() {
    synchronized (XXX.locker) {
        try {
            XXX.locker.wait();
        } catch (InterruptedException e) {
            //do something
        }
    }
    //其它工作代码
    //...
}主线程 a 事儿做完了再    //...
    XXX.locker.notifyAll();
    //...

Answer 7

但是，如果主线程万一先执行了notifyall，其他线程不是要等到花儿也谢了？
似乎有点问题。

Answer 8

你不让它先执行 XXX.locker.notifyAll(); 不就完了吗，你有主控权。另外如果程序没 Bug 哪来那么多万一。

Answer 9

如何高效地做到不让他执行notifyall啊

Answer 10

期待的执行顺序是：要求主线程wait后，才能让线程池中的大量线程同步开始run，

Answer 11

晕，这么复杂吗？1 你直接让主线程需要的内容运行完毕后，再启动那些线程不就行了。
2 使用同步锁+标记参考我这个代码，虽然说明的是另一个问题，但作用和你所的一样，让子线程等待，直到主线程waithttp://www.java2000.net/viewthread.jsp?tid=7085

Answer 12

您给出的这段代码有一条正确执行路线，但是也有一条死锁路线
如果把Thread.sleep(1000);//try catch needed换个位置，主从线程都会等死在那里。
不知道这个问题有没有在任何情况下都能按照既定目标：“主线程wait后，才能让线程池中的大量线程同步开始run”执行的方法
public class MyTest {
  public static void main(String[] args) throws Exception {
    new TestThread().start();
    new TestThread().start();
    Thread.sleep(1000);
    System.out.println("Doing something...");
    synchronized (lock) {
      lock.notifyAll();
      lock.wait();
      condition = true; // 语句1
      lock.notifyAll(); // 语句2
    }
    System.exit(0);
  }  static volatile Object lock = new Object();  static volatile Boolean condition = false;;
}class TestThread extends Thread {
  @Override
  public void run() {
   Thread.sleep(1000);//try catch needed
    synchronized (MyTest.lock) {
      while (!MyTest.condition) {
        try {
          MyTest.lock.wait();
          System.out.println(getId());
          MyTest.lock.notifyAll();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
      System.out.println(getId());
    }
  }
}

Answer 13

Often a thread needs to wait for a signal from another thread before it can proceed. There are various types of signals. A persistent signal (sometimes called a latch or a gate) is a signal that remains set until a single thread has received it. A transient signal (or pulse) is a signal that releases one or more waiting threads but is lost if no threads are waiting.