parallel threads need to reach a point, wait on another thread, and then resume - best approach?

Here's the (simplified) scenario:

• I have threads A, B, C running in parallel.
• Once all 3 threads have reached Step 7 of their execution, they must wait. (Each thread will reach Step 7 at a different time, which can't be known in advance).
• Thread D then kicks off and runs to completion.
• Only after D completes can A, B, and C resume and run to completion.

What would be a good tool or design to approach this with?

The concurrency and semaphore examples I've looked at so far seem to only deal with 2 threads, or assume that the parallel threads are doing similar things but just sharing a var or message-passing. I haven't yet found anything that works with the scenario above. I'm continuing to look into it and will update with any findings.

A CountDownLatch might work if it didn't need to have the other threads exit. Or if it could work in reverse - make n threads wait until thread D exits.

I'm fairly new to concurrency (college classes do not give it anywhere near the time it needs), so bear with me. Dropping this link here in case anyone with a similar question stumbles on this thread: HowToDoInJava - Concurrency

I would use a Phaser

import java.util.concurrent.Phaser;
class Scratch {
public static class ThreadABCWorker implements Runnable {
String threadName;
Phaser phaser;
public ThreadABCWorker(String threadName, Phaser phaser) {
this.threadName =  threadName;
this.phaser = phaser;
}
@Override
public void run() {
System.out.println("Thread " + threadName + " has started");
// do steps 1-7 as part of phase 0
phaser.arriveAndAwaitAdvance();
// All the work for phase 1 is done in Thread D, so just arrive again and wait for D to do its thing
phaser.arriveAndAwaitAdvance();
System.out.println("Continue Thread" + threadName);
}
}
public static void main(String[] args) {
var phaser = new Phaser(4);
var threadA = new Thread(new ThreadABCWorker("A", phaser));
var threadB = new Thread(new ThreadABCWorker("B", phaser));
var threadC = new Thread(new ThreadABCWorker("C", phaser));
var threadD = new Thread(() -> {
phaser.arriveAndAwaitAdvance(); // D shouldn't start doing its thing until phase 1
System.out.println("Thread D has started");
try {
System.out.println("sleep 100");
Thread.sleep(100);
System.out.println("Thread D has finished");
phaser.arriveAndDeregister(); // All done, let ths other threads continue
} catch (InterruptedException e) {
e.printStackTrace();
}
});
threadA.start();
threadB.start();
threadC.start();
threadD.start();
}
}

Example output:

Thread A has started
Thread C has started
Thread B has started
Thread D has started
sleep 100
Thread D has finished
Continue ThreadB
Continue ThreadA
Continue ThreadC

Here's what I came up with using the CountDownLatch itself. It doesn't necessarily have to countdown only when threads complete.

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CountDownLatch;
/**
* Sample class that utilizes very simple thread creation/execution.
* <p>
* DISCLAIMER: This class isn't meant to show all cross-cutting concerns. It just focuses on the task presented.
* Naming conventions, access modifiers, etc. may not be optimal.
*/
public class ATech {
private static long startThreadTime;
private static CountDownLatch primaryCountDownLatch = new CountDownLatch(3);
private static CountDownLatch secondaryCountDownLatch = new CountDownLatch(1);
public static void main(String[] args) {
List<Thread> threads = Arrays.asList(
new Thread(new ThreadType1("A", 1, 5)),
new Thread(new ThreadType1("B", 5, 1)),
new Thread(new ThreadType1("C", 10, 10)),
new Thread(new ThreadType2("D", 5))
);
startThreadTime = System.currentTimeMillis();
System.out.println("Starting threads at (about) time 0");
threads.forEach(Thread::start);
try {
for (Thread thread : threads) {
thread.join();
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("All threads completed at time " + (System.currentTimeMillis() - startThreadTime));
}
static class ThreadType1 implements Runnable {
public ThreadType1(String name, int executionTimePreWaitInSeconds, int executionTimePostWaitInSeconds) {
this.execTimePreWait = executionTimePreWaitInSeconds;
this.execTimePostWait = executionTimePostWaitInSeconds;
this.name = name;
}
int execTimePreWait;
int execTimePostWait;
String name;
@Override
public void run() {
System.out.println("Execution thread " + name + ". Waiting for " + execTimePreWait + " seconds");
try {
Thread.sleep(execTimePreWait * 1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
// Done doing whatever we were doing, now we let the other thread now we're done (for now)
System.out.println("Thread " + name + " completed at time " + (System
.currentTimeMillis() - startThreadTime) + ". Waiting for latch");
primaryCountDownLatch.countDown();
try {
secondaryCountDownLatch.await();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(
"Thread " + name + " awoken again at time " + (System.currentTimeMillis() - startThreadTime));
System.out.println("Thread " + name + " will sleep for " + execTimePostWait + " seconds");
try {
Thread.sleep(execTimePostWait * 1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(
"Thread " + name + " completed fully at time " + (System.currentTimeMillis() - startThreadTime));
}
}
static class ThreadType2 implements Runnable {
String name;
int execTime;
public ThreadType2(String name, int executionTimeInSeconds) {
this.name = name;
this.execTime = executionTimeInSeconds;
}
@Override
public void run() {
System.out.println("Thread " + name + " waiting for other threads to complete");
try {
primaryCountDownLatch.await();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("Thread " + name + " woke up at time " + (System.currentTimeMillis() - startThreadTime));
System.out.println("Thread " + name + " will work for " + execTime + " seconds");
try {
Thread.sleep(execTime * 1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("Thread " + name + " completed at time " + (System.currentTimeMillis() - startThreadTime));
secondaryCountDownLatch.countDown();
}
}
}

Sample output:

Starting threads at (about) time 0
Execution thread A. Waiting for 1 seconds
Execution thread C. Waiting for 10 seconds
Execution thread B. Waiting for 5 seconds
Thread D waiting for other threads to complete
Thread A completed at time 1033. Waiting for latch
Thread B completed at time 5034. Waiting for latch
Thread C completed at time 10034. Waiting for latch
Thread D woke up at time 10034
Thread D will work for 5 seconds
Thread D completed at time 15034
Thread A awoken again at time 15034
Thread C awoken again at time 15034
Thread A will sleep for 5 seconds
Thread B awoken again at time 15034
Thread B will sleep for 1 seconds
Thread C will sleep for 10 seconds
Thread B completed fully at time 16035
Thread A completed fully at time 20034
Thread C completed fully at time 25034
All threads completed at time 25034
Process finished with exit code 0