How to make a main thread wait until all other threads die out?

[Bhargav Bobby]

In my program i have 10 threads working simultaneously, the threads are used to fetch data(one row per thread)from the database and send it to some other method. when the data in the database reaches the nth record the first thread that encounters this will spawn a main governing thread and it dies out. My problem is that i have to wait till all the other threads die out for the main governing thread to continue with its operation. How can i know the wait time for the main governing thread to suspend with its operation till all the other threads die out. Can anyone give me a solution for how to wait till the other threads die out and then continue with the main threads execution... NOTE: All the threads are individual threads, they are not in a single pool..

[Edward Harned]

Look at Thread.join()

Your main thread can create the "main governing thread" and pass it the thread objects for the other threads. The main... can issue a join(). This will block until the joined threads complete.

You could just make the main thread the governing thread.

[Chandra Bhatt]

Hi Edward,

Could you please give an example for this, I tried that but no.
I want the main thread to join all the threads.

Thanks,

[Chandra Bhatt]

I tried this but it does not look good.

class UThread1 extends Thread {

Thread th1;
UThread1(Thread th1) {
this.th1 = th1;
}

public void run() {
System.out.println(Thread.currentThread().getName() + " running");
}
}
 
public class Example3 {
 
public static void main(String... args) throws Exception{

UThread1[] th = new UThread1[10]; 

for(int i=0; i<th.length; i++) { 
th[i] = new UThread1(Thread.currentThread());
th[i].start();
}
try{
th[0].join();
th[1].join();
th[2].join();
th[3].join();
th[4].join();
th[5].join();
th[6].join();
th[7].join();
th[8].join();
th[9].join();
}catch(InterruptedException ie){
ie.printStackTrace();
}
System.out.println("main ends");
}
}

Please suggest other nice way to do so.

Thanks,

[Edward Harned]

Look nice?

[Jim Yingst]

Well, you could always use another for loop around the join() calls. Copying the same code 10 times (with a slight change of index) is often a clue that a for loop can be introduced. Other than that, what's wrong with the way the code "looks"?

[Chandra Bhatt]

Thanks Jim,

I made change to the code, availing the benefit of for loop:

for(int i=0; i<th.length; i++) {
try{ 
th[i].join();
}catch(InterruptedException ie) {
ie.printStackTrace();
}
}

Thanks,

[M Poongundran]

public class MlThread {

	public static void main(String[] args) {
		
		ThreadGroup lThreadGroup = new ThreadGroup("CThread's Group");
		CThread lCThread;
		
		
		for(int count =0; count< 10; count++){
			lCThread = new CThread(lThreadGroup, "Thread - "+count);
			lCThread.start();
		}
		


		while(lThreadGroup.activeCount() > 0 ){
			try {
				System.out.println("Waiting for " + lThreadGroup.activeCount() +" CThreads to Complete");
				Thread.sleep(1000* 2); //Main Thread or someThradObject.sleep();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}


class CThread extends Thread{
	
	public CThread(ThreadGroup pThreadGroup, String pThreadName) {
		super(pThreadGroup, pThreadName);
	}
	
	public void run(){
		System.out.println(this.getName() + " Thread begins..");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(this.getName() + " Thread ends...");
	}
	
}

[Henry Wong]

M Poongundran wrote:

public class MlThread {

	public static void main(String[] args) {
		
		ThreadGroup lThreadGroup = new ThreadGroup("CThread's Group");
		CThread lCThread;
		
		
		for(int count =0; count< 10; count++){
			lCThread = new CThread(lThreadGroup, "Thread - "+count);
			lCThread.start();
		}
		


		while(lThreadGroup.activeCount() > 0 ){
			try {
				System.out.println("Waiting for " + lThreadGroup.activeCount() +" CThreads to Complete");
				Thread.sleep(1000* 2); //Main Thread or someThradObject.sleep();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}


class CThread extends Thread{
	
	public CThread(ThreadGroup pThreadGroup, String pThreadName) {
		super(pThreadGroup, pThreadName);
	}
	
	public void run(){
		System.out.println(this.getName() + " Thread begins..");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(this.getName() + " Thread ends...");
	}
	
}

Two points.

First, posting code without any explanation or any context is not very useful.

Second, answering a topic that hasn't been responded to for *five* years is also likely useless -- as the original poster has likely moved on.


Perhaps your time is better spent helping someone who may be still expecting an answer?
Henry

PS... Welcome to the ranch !!

[M Poongundran]

Try this.

Main Thread will be in sleep until all the execution of treads in "lThreadGroup" gets completed. Execution of Threads in Group "lThreadGroup" are independent.

public class MlThread {

	public static void main(String[] args) {
		
		ThreadGroup lThreadGroup = new ThreadGroup("CThread's Group");
		CThread lCThread;
		
		
		for(int count =0; count< 10; count++){
			lCThread = new CThread(lThreadGroup, "Thread - "+count);
			lCThread.start();
		}
		


		while(lThreadGroup.activeCount() > 0 ){
			try {
				System.out.println("Waiting for " + lThreadGroup.activeCount() +" CThreads to Complete");
				Thread.sleep(1000* 2); //Main Thread or someThradObject.sleep();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}


class CThread extends Thread{
	
	public CThread(ThreadGroup pThreadGroup, String pThreadName) {
		super(pThreadGroup, pThreadName);
	}
	
	public void run(){
		System.out.println(this.getName() + " Thread begins..");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(this.getName() + " Thread ends...");
	}
	
}