On 8 Feb., 12:43, javatea...@gmail.com wrote:

======================================
1. If you use a main method, you use the main thread.
In this case it is ok to wait for your MyMainThread.

public void myFunc() {
MyMainThread thread = new MyMainThread();
thread.start();
...
while (thread.isAlive()) try{ Thraed.sleep(100); } catch(Exception err)
{}
exec(thread.getArrayListFromThread());
...

}

class MyMainThread extends Thread{
private ArayList arrayListFromThread;

public void run(){
//start all Subthreads
while ( /*one of the subtreads runs */) {
          try{ Thraed.sleep(100); } catch(Exception err){}
}
}

public ArrayList getArrayListFromThread(){return arrayListFromThread;}
}
======================================
2. If you use a Swing UI, you use the Swing-Thread.
In this case is it better to invoke exec(arrayListFromThread) in
MyMainThread.

public void myFunc() {
MyMainThread thread = new MyMainThread();
thread.start();
}

class MyMainThread extends Thread{
private ArayList arrayListFromThread = new ArrayList();

public void run(){
//start all Subthreads
while ( /*one of the subthreads runs */) {
       try{ Thraed.sleep(100); } catch(Exception err){}
}
exec(arrayListFromThread);
...
}
}

======================================
All Subthreads have to synchronize all access to ArayList!

I have two solution for starting all Subthreads and waiting:
solution 1:

Thread[] t=new Thread[200];

public void run(){
for (int i...){
  t[i]=new Thread();
  t[i].start();
}
while ( oneSubThreadIsAlive()) {
   ry{ Thraed.sleep(100); } catch(Exception err){}
}
...
}

public boolean oneSubThreadIsAlive(){
 for (int i...) if (t[i].isAlive()) retrun true;
 return false;
}

solution 2:

Thread[] t=new Thread[200];
int runs=0;
Object mon=new Object();

public void run(){
for (int i...){
  t[i]=new SubThread();
  t[i].start();
  synchronized(mon){runs++;}
}
while ( runs>0) {
   try{ Thraed.sleep(100); } catch(Exception err){}
}
...
}

class SubThread extends Thread{
public void run(){
 try{
 ...
 // fill ArayList used synchronized-block
 ...
 // ready:
 }finally{ synchronized(mon){runs--;} }
}
}

================================
Filling a ArayList used synchronized-block:
synchronized(mon){arrayListFromThread.add("something");}

Janush

this sounds like a bad idea, unless you make sure your using proper
synchronization...

I suggest looking into the standard ExecutorService and
CompletionService classes.