Synchronized execution of threads

Question

How do I synchronize the execution of two threads?
I am using two threads, the main thread to handle input and output, and a secondary thread to execute third party procedural code.
The main thread has to wait for commands from the procedural thread and then relay those to the client.
While the client has control, the procedural thread has to wait and vice versa. I couldn't get this to work yet.
Below is the simplest example I could extract from the code. I have tried it with java.util.concurrent as well but couldn't pause the main (servlet) thread with that, only threads in the thread pool.
Your help will be greatly appreciated!
Here is the code :
[http://connexioncafe.info/java/SyncExample.java|http://connexioncafe.info/java/SyncExample.java]
Thank you in advance!

Answer 1

I'll try and post the code in three parts:
* This is a simulation of a server.  It has two threads:
* [1] main thread used for input and output (in this case communication with command line client).
*      it could be a servlet in practice
* [2] and a procedural thread for executing third party code (e.g. PHP)
* The main thread start the procedural thread
*      *the main thread waits
* the procedural thread reads a stack, one item at a time
* if the command in the stack is an input or output command
* *the procedural thread sets the command on the main thread
* *the procedural thread notifies/wakes up the main thread [A]
* *the procedural thread waits
* the main thread is woken up by the procedural thread [A]
* *it executes the command as set by the procedural thread
* *it sets the result on the message variable
* *it notifies/wakes up the procedural thread
* *the main thread waits for the next command from the procedural thread [B]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class SyncExample {
//a simple int value that is visible by both threads used for messaging
public int message = -1;
//a command that is passed between threads either executing on the client or server side
public int command = -1;
//all the possible commands
public static final int DO_INPUT = 1;
public static final int DO_OUTPUT = 2;
public static final int DO_QUIT = 3;
public static final int DO_STORAGE = 4;
public static final int DO_PROCESS = 5;
//commands with an int value greater or equal to SERVER_SIDE executes on the server side
public static final int SERVER_SIDE = 3;
//a lock used to wait() the procedural thread
public final Object procLock = new Object();
//a lock used to wait() the main thread
public final Object mainLock = new Object();
//a lock used to sync message value between threads
public final Object msgLock = new Object();
//a lock used to sync command value between threads
public final Object cmdLock = new Object();
//========================================================================== Procedural Thread
public class ProcThread extends Thread {
//some third party code that will be executed by this thread
private AlgorithmI aProc;
//some functions that will be used to execute the third party code
private final SysFunctions sysFunctions;
public ProcThread(AlgorithmI aProc, SysFunctions sf) {
this.aProc = aProc;
this.sysFunctions = sf;
@Override
public void run() {
int cmd = 0;
for (int i = 0; i < aProc.getStack().length; i++) {
cmd = aProc.getStack();
if (cmd >= SERVER_SIDE) {
switch (cmd) {
case DO_STORAGE:
sysFunctions.storage();
break;
case DO_PROCESS:
aProc.calculate();
break;
default:
break;
} else {
setCommand(cmd);
//TODO: RESUME MAIN THREAD SO THAT IT CAN COMMUNICATE WITH CLIENT
synchronized (mainLock) {
mainLock.notify();
//TODO: PAUSE THIS PROCEDURAL THREAD UNTIL MAIN THREAD HAS COMPLETED THE COMMAND
synchronized (procLock) {
try {
procLock.wait();
} catch (InterruptedException ex) {
//interrupted
switch (cmd) {
case DO_INPUT:
aProc.setValue(getMessage());
break;
case DO_OUTPUT:
break;
default:
break;
* An interface that has to be implemented by third party procedures
public interface AlgorithmI {
public void calculate();
public int[] getStack();
public void setValue(int message);
//written by someone else which I do not have control over
public class ThirdPartyProcedure implements AlgorithmI {
//just two values that will be added together
private int value1 = 0;
private int value2 = 0;
// an array of commands that will be executed by ProcThread
private int[] stack = {
SyncExample.DO_STORAGE,
SyncExample.DO_INPUT,
SyncExample.DO_STORAGE,
SyncExample.DO_INPUT,
SyncExample.DO_STORAGE,
SyncExample.DO_PROCESS,
SyncExample.DO_STORAGE,
SyncExample.DO_OUTPUT,
SyncExample.DO_QUIT};
public synchronized void setValue(int value) {
if (value1 == 0) {
value1 = value;
} else {
value2 = value;
public void calculate() {
setMessage(value1 + value2);
public int[] getStack() {
return stack;
// continued below...
Edited by: datahpile on Aug 20, 2010 6:27 AM