I want to execution of a Threads in sequence

[Bk Jacky]

Hi Ranchers,

I want to execute Threads in sequence.

Suppose I have Three Threads A, B and C

A(Has lock of object) is performing some job and B&C are waiting on that.

when A will release lock B should get the Lock not C

After that C should get the lock

I was thinking about Priority Setting of each thread.But i am not sure it will work or not .

Need your suggestions...

[Surya Kant]

Why dont you try making use of wait() & notify() methods?
It is very easy to do.Priority setting will not work.

[Surya Kant]

Why dont you try wait and notify methods?
It is not possible to achieve the same with priority settings.

[Bk Jacky]

Can you please explain me with some sample code.

[Henry Wong]

http://java.sun.com/docs/books/tutorial/essential/concurrency/

[Steve Luke]

A simple wait() notify() would have to be modified with some signals to make sure the proper order is conserved. Here is an example:

/* This class just helps marshal locking in correct order */
public class LockBox
{
    private volatile boolean secondProcessRun = false;
    private volatile boolean thirdProcessRun = false;

    public boolean setSecondProcessRun(boolean canRun)
    {
        secondProcessRun = canRun;
    }
    public boolean canSecondProcessRun() { return secondProcessRun; }

    public boolean setThirdProcessRun(boolean canRun)
    {
        thirdProcessRun = canRun;
    }
    public boolean canThirdProcessRun() { return thirdProcessRun; }
}

/* Runnable for Thread A */
public class A implements Runnable
{
    private final LockBox dataLock;

    public A(LockBox lock) { this.dataLock = lock; }

    public void run()
    {
        //do concurrent stuff

        synchronized(lock)
        {
            //do sequential stuff

            //Tell B to run
            lock.setSecondProcessRun(true);
            lock.notifyAll();
        }
        //More concurrent stuff
    }
}

public class B implements Runnable
{
    private final LockBox dataLock;
    public B(LockBox lock) { this.dataLock = lock; }

    public void run()
    {
        //do concurrent stuff

        synchronized(lock)
        {
            while(!lock.canSecondProcessRun())
            {
                 lock.wait();
             }

            //do sequential stuff

            //Tell C to run
            lock.setThirdProcessRun(true);
            lock.notifyAll();
        }
        //More concurrent stuff
    }
}

public class C implements Runnable
{
    private final LockBox dataLock;
    public C(LockBox lock) { this.dataLock = lock; }

    public void run()
    {
        //do concurrent stuff

        synchronized(lock)
        {
            while(!lock.canThirdProcessRun())
            {
                 lock.wait();
             }

            //do sequential stuff
        }
        //More concurrent stuff
    }
}

Other options would be to have C lock on a different object then A. B initially locks on the same one A is using and wait()s. A notify()s B, B does its work, then synchronizes on the same Object as C and notify()s it. This can be a bit tricky to implement though, you have to be sure all your data you are protecting are properly protected with the double locks, and that you don't get into a deadlock situation.

However, if your target app is at Java 1.5 or later, you should probably take advantage of the java.util.concurrent.Lock/Condition classes. Look up the tutorial for Concurrency in Java and you will see example usage.

/*** Edit ***/
The notify()s should be notifyAll()s, changed in above code

[Arka Guhathakurta]

There is no way to determine if B will run after A has send notify().Remember notify() invokes a thread from the wait set and then that thread competes for acquisition of lock on an object.Only the Operating system determines which thread will take the lock.Also note that if there are 2 threads X and Y where X has maximum priority and Y has minimum priority and both are in ready to run state...in such a scenario it only increases the chances of X in running state over Y but does not guarantee execution of X before Y.

Good Luck!

[Alan Mehio]

I was thinking about Priority Setting of each thread.But i am not sure it will work or not .

It is generally wise to resist the temptation to tweak thread priorities. As soon as you start modifiying priorities, the behavior of your application becomes platform-specific and you introduce the risk of starvation.

[Alan Mehio]

Just made some correction based on Steve Luke code. Basically the notifiier will triggers the first thread to run and will wait until all get executed

    

/* This class just helps marshal locking in correct order */
public class LockBox {
	private  boolean firstProcessRun = false; // volatile not needed since there is a lock on this
	private  boolean secondProcessRun = false;
	private  boolean thirdProcessRun = false;

	public void setFirstProcessRun(boolean canRun) {
		this.firstProcessRun = canRun;
	}
	
	public boolean canFirstProcessRun() {
		return firstProcessRun;
	}
	
	public void setSecondProcessRun(boolean canRun) {
		secondProcessRun = canRun;
		
	}

	public boolean canSecondProcessRun() {
		return secondProcessRun;
	}

	public void setThirdProcessRun(boolean canRun) {
		thirdProcessRun = canRun;
	}

	public boolean canThirdProcessRun() {
		return thirdProcessRun;
	}
	
	public boolean allExecuted() {
		return firstProcessRun && secondProcessRun && thirdProcessRun;
	}
	
	public static void main(String args[]) throws Exception {
		LockBox lock = new LockBox();
		Thread a = new Thread(new A(lock));
		Thread b = new Thread(new B(lock));
		Thread c = new Thread (new C(lock));
		c.start();
		a.start();
		b.start();
		
		Thread notifier = new Thread (new Notifier(lock));
		notifier.start();
		
		
	}
	

 static class Notifier implements Runnable {
	 private final LockBox lock;
	 
	 public Notifier(LockBox lock) {
		 this.lock = lock;
	 }
	 
	 public void run() {
		 synchronized(lock) {
		 while(!lock.allExecuted()) {
		    try  {
		    lock.setFirstProcessRun(true);
		    lock.notifyAll();
		    lock.wait();
		    }catch(InterruptedException interEx) {
		    	Thread.currentThread().interrupt();
		    }
		    
		  }

		 }
		 
		 
	 }
 }
	
	
/* Runnable for Thread A */
static class A implements Runnable {
	private final LockBox lock;

	public A(LockBox lock) {
		this.lock = lock;
	}

	public void run() {
		// do concurrent stuff

		synchronized (lock) {
			while (!lock.canFirstProcessRun()) {
				try {
				lock.notify();
				lock.wait();
				}catch(InterruptedException inter) {
					Thread.currentThread().interrupt();
				}
			}

			// Tell B to run
			System.out.print("A");
			lock.setSecondProcessRun(true);
			lock.notifyAll();
		}
		// More concurrent stuff
	}
}

static class B implements Runnable {	
	private final LockBox lock;
	public B(LockBox lock) {
		this.lock = lock;
	}

	public void run() {
		// do concurrent stuff

		synchronized (lock) {
			while (!lock.canSecondProcessRun()) {
				try {
			    lock.notify();
				lock.wait();
				}catch(InterruptedException inter) {
					Thread.currentThread().interrupt();
				}
			}

			// do sequential stuff

			// Tell C to run
			System.out.print("B");
			lock.setThirdProcessRun(true);
			lock.notifyAll();
		}
		// More concurrent stuff
	}
	
	}

	
static class C implements Runnable {
	private final LockBox lock;

	public C(LockBox lock) {
		this.lock = lock;
	}

	public void run() {
		// do concurrent stuff

		synchronized (lock) {
			while (!lock.canThirdProcessRun()) {
				try {
			    lock.notify();
				lock.wait();
				}catch(InterruptedException inter) {
					Thread.currentThread().interrupt();
				}
			}
			
			System.out.print("C");
			lock.notifyAll();

			// do sequential stuff
		}
		// More concurrent stuff
	}
}


}

I hope this correction reinforce the order for thread execution.

[Bk Jacky]

Thanks all for you kind help specially Alan and Luke.