How do I wait for my thread factory to finish executing all its tasks?

Question

I'm using Spring 4.3.8.RELEASE with Java 7. I want to create a thread factory to help manage certain workers in my application. I declare my thread factory like so

<bean id="myprojectThreadFactory" class="org.springframework.scheduling.concurrent.CustomizableThreadFactory">
    <constructor-arg value="prefix-"/>
</bean>
<bean id="myprojectTaskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
    <property name="threadFactory" ref="myprojectThreadFactory"/>
    <property name="corePoolSize" value="${myproject.core.thread.pool.size}" />
    <property name="maxPoolSize" value="${myproject.max.thread.pool.size}" />
</bean>

However, I'm having trouble "join"ing on the threads. That is, I want to wait for all work to be completed before continuing with a certain task so I have

    m_importEventsWorker.work();
    m_threadExecutor.shutdown();
    System.out.println("done.");

in which my thread pool is executed like so

public void work(final MyWorkUnit pmyprojectOrg)
{
    final List<MyWorkUnit> allOrgs = new ArrayList<MyWorkUnit>();
    if (pmyprojectOrg != null)
    {
        processData(pmyprojectOrg.getmyprojectOrgId());
    } else { 
        allOrgs.addAll(m_myprojectSvc.findAllWithNonEmptyTokens());
        // Cue up threads to execute
        for (final MyWorkUnit myprojectOrg : allOrgs)
        {
            m_threadExecutor.execute(new Thread(new Runnable(){
                @Override
                public void run()
                {
                    System.out.println("started.");
                    processData(myprojectOrg.getmyprojectOrgId());
                }
            }));
        }   // for

Yet what gets printed out is

done.
started.
started.

So clearly I'm not waiting. What's the right way to wait for my threads to finish working?

what do you want to do with the threads ? are they working on the same dataset or separated datas ? Can you describe the flow ? — jeorfevre, Jun 12 '17 at 15:51
The threads are wokring on different data sets. I would like to know when all the threads are done with their tasks, but evidently the "shutdown" mehod isn't the way to go. — Dave, Jun 12 '17 at 16:01
You can call `m_threadExecutir.submit(...)`,and that method will return a `FutureTask` instance,you should call `FutureTask`'s `get()` method which will wait for the task completed. — dabaicai, Jun 12 '17 at 16:08
Do I have to invoke that for each potentially active therad? For instance if I have 100 iterations of my loop do I have to call the "submit" method 100 times? — Dave, Jun 12 '17 at 16:17
I'm too lazy to post this as answer, buy I think you are looking for awaitTermination method of executorService. This should be called right after shutdown. https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ExecutorService.html#awaitTermination(long,%20java.util.concurrent.TimeUnit) — Sami Korhonen, Jun 14 '17 at 17:34

score 1 · Answer 1 · answered Jun 15 '17 at 09:15

You can create a fixed thread pool by using ExecutorService and check whether the pool size is empty or not:

ExecutorService executor = Executors.newFixedThreadPool(50);

If you run your tasks by using this executor and check the thread pool size periodically by using @Scheduled fixedRate or fixedDelay, you can see if they are finished or not.

ThreadPoolExecutor poolInfo = (ThreadPoolExecutor) executor;
Integer activeTaskCount = poolInfo.getActiveCount();

if(activeTaskCount = 0) {
    //If it is 0, it means threads are waiting for tasks, they have no assigned tasks.
    //Do whatever you want here!
}

That will tell me at a fixed point in time if I'm finsihed, but I want to actually pause program execution until everything is completed. — Dave, Jun 15 '17 at 14:54

gati sahu · Answer 2 · 2017-06-12T16:49:49.047

A CountDownLatch is initialized with a given count. This count is decremented by calls to the countDown() method. Threads waiting for this count to reach zero can call one of the await() methods. Calling await() blocks the thread until the count reaches zero.

You can use CountDownLatch to main thread to wait for completion all the task.You can declare CountDownLatch with size as number of task CountDownLatch latch = new CountDownLatch(3); in main thread call await() method to wait and every task completion call countDown()

public void work(final MyWorkUnit pmyprojectOrg)
{
    final List<MyWorkUnit> allOrgs = new ArrayList<MyWorkUnit>();
    if (pmyprojectOrg != null)
    {
        processData(pmyprojectOrg.getmyprojectOrgId());
    } else { 
        allOrgs.addAll(m_myprojectSvc.findAllWithNonEmptyTokens());

        CountDownLatch latch = new CountDownLatch(allOrgs.size());

        // Cue up threads to execute
        for (final MyWorkUnit myprojectOrg : allOrgs)
        {
            m_threadExecutor.execute(new Thread(new Runnable(){
                @Override
                public void run()
                {
                    System.out.println("started.");
                    processData(myprojectOrg.getmyprojectOrgId());
                   latch.countDown();
                }
            }));
        }  
       //After for loop
       latch.await();

Example:

CountDownLatch latch = new CountDownLatch(3);

Waiter      waiter      = new Waiter(latch);
Decrementer decrementer = new Decrementer(latch);

new Thread(waiter)     .start();
new Thread(decrementer).start();

public class Waiter implements Runnable{

    CountDownLatch latch = null;

    public Waiter(CountDownLatch latch) {
        this.latch = latch;
    }

    public void run() {
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Waiter Released");
    }
}

public class Decrementer implements Runnable {

CountDownLatch latch = null;

public Decrementer(CountDownLatch latch) {
    this.latch = latch;
}



 public void run() {

        try {
            Thread.sleep(1000);
            this.latch.countDown();

            Thread.sleep(1000);
            this.latch.countDown();

            Thread.sleep(1000);
            this.latch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

THanks but I'm not clear how I would apply this to my question. Are you saying when I create a Runnable instance I should create your "Waiter" class instead? — Dave, Jun 12 '17 at 16:38
Create a countdown latch instance and pass to every runnable instance and do countdown. After calling work call await method — gati sahu, Jun 12 '17 at 16:41
The "m_threadExecutor.shutdown();" was actually being invoked from a JUnit test, b/c in the test I wanted to check some conditions after the thrads were finished. I'd like to avoid adding code into my core project just to satisfy a JUnit test but if there is no other way to do this, I'll consider it. — Dave, Jun 12 '17 at 16:58

Dave · Accepted Answer · 2017-06-14T19:10:52.960

Since I'm using Spring's ThreadPoolTaskExecutor, I found the below which suited my needs ...

protected void waitForThreadPool(final ThreadPoolTaskExecutor threadPoolExecutor)
{
    threadPoolExecutor.setWaitForTasksToCompleteOnShutdown(true);
    threadPoolExecutor.shutdown();    
    try {
        threadPoolExecutor.getThreadPoolExecutor().awaitTermination(30, TimeUnit.SECONDS);
    } catch (IllegalStateException e) {
      e.printStackTrace();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
}   // waitForThreadPool

How do I wait for my thread factory to finish executing all its tasks?

3 Answers3