How to make the main thread wait for the other threads to complete in ThreadPoolExecutor

Question

I am using the ThreadPoolExecutor to implement threading in my Java Application.

I have a XML which I need to parse and add each node of it to a thread to execute the completion. My implementation is like this:

parse_tp is a threadpool object created & ParseQuotesXML is the class with the run method.

        try {     
           List children = root.getChildren();               
        Iterator iter = children.iterator();

        //Parsing the XML     
        while(iter.hasNext()) {       
           Element child = (Element) iter.next();           
           ParseQuotesXML quote = new ParseQuotesXML(child, this);         
           parse_tp.execute(quote);         
        }
    System.out.println("Print it after all the threads have completed");
        catch(Exception ex) {  
        ex.printStackTrace();      
        }
        finally {  
    System.out.println("Print it in the end.");
if(!parse_tp.isShutdown()) {
                if(parse_tp.getActiveCount() == 0 && parse_tp.getQueue().size() == 0 ) {
                    parse_tp.shutdown();                    
                } else {
                    try {
                        parse_tp.awaitTermination(30, TimeUnit.SECONDS);
                    } catch (InterruptedException ex) {
                        log.info("Exception while terminating the threadpool "+ex.getMessage());
                        ex.printStackTrace();
                    }
                }
            }
          parse_tp.shutdown();  
        }

The problem is, the two print out statements are printed before the other threads exit. I want to make the main thread wait for all other threads to complete. In normal Thread implementation I can do it using join() function but not getting a way to achieve the same in ThreadPool Executor. Also would like to ask if the code written in finally block to close the threadpool proper ?

Thanks, Amit

score 4 · Answer 1 · edited May 23 '17 at 11:48

4

A CountDownLatch is designed for this very purpose. Examples may be found here and here. When the number of threads is not known in advance, consider a Phaser, new in Java 1.7, or an UpDownLatch.

edited May 23 '17 at 11:48

Community

1
1

answered Dec 15 '09 at 19:05

trashgod

203,806
29
246
1,045

Thanks trashgod, but I dont have a exact count of the nodes of xml which I need to parse, so wont be able to use CountDownLatch. But I wasn't aware of any such property available in Java, so thanks a lot for this. – Amit Dec 18 '09 at 10:28
Excellent. As suggested above, `Future` is more flexible, but I added a link to an UpDownLatch example, too. – trashgod Dec 18 '09 at 22:06
Note that a _Phaser_ has a limit of maximal count of 65535. Not sure if there is a simple workaround. – David Balažic Oct 04 '15 at 19:35
The [API](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Phaser.html) suggests _tiering_. – trashgod Oct 05 '15 at 02:14

Bob Cross · Accepted Answer · 2009-12-18T14:04:00.990

To answer your second question, I think you are doing a reasonable job trying to clean up your thread pool.

With respect to your first question, I think the method that you want to use is submit rather than execute. Rather than try to explain it all in text, here's an edited fragment from a unit test that I wrote that makes many tasks, has each of them do a fragment of the total work and then meets back at the starting point to add the results:

final AtomicInteger messagesReceived = new AtomicInteger(0);

// ThreadedListenerAdapter is the class that I'm testing 
// It's not germane to the question other than as a target for a thread pool.
final ThreadedListenerAdapter<Integer> adapter = 
    new ThreadedListenerAdapter<Integer>(listener);
int taskCount = 10;

List<FutureTask<Integer>> taskList = new ArrayList<FutureTask<Integer>>();

for (int whichTask = 0; whichTask < taskCount; whichTask++) {
    FutureTask<Integer> futureTask = 
        new FutureTask<Integer>(new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            // Does useful work that affects messagesSent
            return messagesSent;
        }
    });
    taskList.add(futureTask);
}

for (FutureTask<Integer> task : taskList) {
    LocalExecutorService.getExecutorService().submit(task);
}

for (FutureTask<Integer> task : taskList) {
    int result = 0;
    try {
        result = task.get();
    } catch (InterruptedException ex) {
        Thread.currentThread().interrupt();
    } catch (ExecutionException ex) {
        throw new RuntimeException("ExecutionException in task " + task, ex);
    }
    assertEquals(maxMessages, result);
}

int messagesSent = taskCount * maxMessages;
assertEquals(messagesSent, messagesReceived.intValue());

I think this fragment is similar to what you're trying to do. The key components were the submit and get methods.

score 1 · Answer 3 · answered Dec 16 '09 at 19:27

1

First of all you can use ThreadPoolExecutor.submit() method, which returns Future instance, then after you submitted all your work items you can iterate trough those futures and call Future.get() on each of them.

Alternatively, you can prepare your runnable work items and submit them all at once using ThreadPoolExecutor.invokeAll(), which will wait until all work items completed and then you can get the execution results or exception calling the same Future.get() method.

answered Dec 16 '09 at 19:27

Eugene Kuleshov

31,461
5
66
67

`ThreadPoolExecutor.invokeAll()` operates on `Callable` objects. Is there a convenience method that can achieve the same result for `Runnable` objects that don't produce any result? – Derek Mahar Sep 27 '12 at 03:41

How to make the main thread wait for the other threads to complete in ThreadPoolExecutor

3 Answers3

Linked