java thread interleaving

Question

I'm trying to interleave the execution of two independent threads. such that both have a run method with 10 iterations and after every iteration i want to context switch the threads.

thread A starts and after doing something like printing passes control to thread B. then thread B prints and passes control back to A and so on until both finish.

What is the effective mechanism to do this?

I'm attaching a sample code. hope you can help.

// Suspending and resuming a thread for Java 2

class NewThread implements Runnable {
  String name; // name of thread
  Thread t;
 // boolean suspendFlag;

  NewThread(String threadname) {
    name = threadname;
    t = new Thread(this, name);
    System.out.println("New thread: " + t);
  //  suspendFlag = false;
    t.start(); // Start the thread
  }
  public String getState()
  {
    Thread t=Thread.currentThread();

    return t.getState().toString(); 
  }
  // This is the entry point for thread.
  public void run() {
    try {
      for(int i = 15; i > 0; i--) {
        System.out.println(name + ": " + i);
        Thread.sleep(200);
        synchronized(this) {
            //SuspendResume.suspendFlag2=false;
            SuspendResume.suspendFlag1=true;
          while(SuspendResume.suspendFlag1) {
            wait();
            //System.out.println(SuspendResume.ob1.t.getState().toString());
           // if(SuspendResume.ob2.t.getState().toString()=="WAITING")
            //  SuspendResume.ob2.t.notify();
          }
        }
      }
    } catch (InterruptedException e) {
      System.out.println(name + " interrupted.");
    }
    System.out.println(name + " exiting.");
  }

  void mysuspend() {
 //   suspendFlag = true;
  }

  synchronized void myresume() {
   // suspendFlag = false;
    notify();
  }
}
class NewThread2 implements Runnable {
      String name; // name of thread
      Thread t;
     // boolean suspendFlag;

      NewThread2(String threadname) {
        name = threadname;
        t = new Thread(this, name);
        System.out.println("New thread: " + t);
      //  suspendFlag = false;
        t.start(); // Start the thread
      }
      public String getState()
      {
        Thread t=Thread.currentThread();

        return t.getState().toString(); 
      }
      // This is the entry point for thread.
      public void run() {
        try {
          for(int i = 15; i > 0; i--) {
            System.out.println(name + ": " + i);
            Thread.sleep(1000);
            synchronized(this) {
                //SuspendResume.suspendFlag1=false;
                //while(SuspendResume.suspendFlag1) {
         //     while(suspendFlag) {
                //wait();
                //System.out.println(SuspendResume.ob2.t.getState().toString());
                //if(SuspendResume.ob1.t.getState().toString()=="WAITING")
                //SuspendResume.ob1.t.notify();
              //}
                SuspendResume.suspendFlag1=false;
                notify();
            }
          }
        } catch (InterruptedException e) {
          System.out.println(name + " interrupted.");
        }
        System.out.println(name + " exiting.");
      }

      void mysuspend() {
     //   suspendFlag = true;
      }

      synchronized void myresume() {
       // suspendFlag = false;
        notify();
      }
    }
class SuspendResume {
     static boolean suspendFlag1=false;
    static NewThread ob1 = new NewThread("One");
    static NewThread2 ob2 = new NewThread2("Two");

   // static boolean suspendFlag2=false;

  public static void main(String args[]) {


    try {
      //Thread.sleep(1000);
      //ob1.mysuspend();
      //System.out.println("Suspending thread One");
      //Thread.sleep(1000);
      //ob1.myresume();
      //System.out.println("Resuming thread One");
     // ob2.mysuspend();
      //System.out.println("Suspending thread Two");
      Thread.sleep(1000);
     // ob2.myresume();
      //System.out.println("Resuming thread Two");
    } catch (InterruptedException e) {
      System.out.println("Main thread Interrupted");
    }

    // wait for threads to finish
    try {
      System.out.println("Waiting for threads to finish.");
      System.out.println(ob1.getState());
      System.out.println(ob1.getState());
      ob1.t.join();
      ob2.t.join();
    } catch (InterruptedException e) {
      System.out.println("Main thread Interrupted");
    }

    System.out.println("Main thread exiting.");
  }
}

Answer 1

First off, I'm not sure what kind of scenario you have where you want to run two threads sequentially over and over again. That sounds like a single thread running two different methods in a loop. None-the-less, it sounds like an interesting challenge so I took it up.

Making use of Java 5's Exchanger class, the solution gets pretty small. I ended up with a single Runnable class. I use two instances of them to pass around a boolean true and boolean false to each other. The Exchanger class facilitates the passing around of the boolean values in a thread safe manner. A Runnable only 'executes' its code when it has the boolean true value.

package interleavedexample;

import java.util.concurrent.Exchanger;
import java.util.logging.Logger;

/**
 *
 */
public class InterleavedRunnable implements Runnable {

  private final String name;

  private final Exchanger<Boolean> exchanger;

  private Boolean state;

  public InterleavedRunnable(String name, Exchanger<Boolean> exchanger, 
       Boolean state) {
    this.name = name;
    this.exchanger = exchanger;
    this.state = state;
  }         

  @Override
  public void run() {
    try {
      while (true) {
        if (state) {
          Logger.getLogger(getClass().getName()).info(name + " is running");
        }
        state = exchanger.exchange(state);
      }
    } catch (InterruptedException ex) {
      Logger.getLogger(name).info("Interrupted");
    }
  }

Setting up the runnables are quite easy:

  public static void main(String[] args) {
    Exchanger<Boolean> exchanger = new Exchanger<Boolean>();
    Thread thread1 = new Thread(new InterleavedRunnable("Thread 1", exchanger, true));
    Thread thread2 = new Thread(new InterleavedRunnable("Thread 2", exchanger, false));
    thread1.start();
    thread2.start();
  }

Anytime you can find existing functionality within the Java API (or well known libraries), you should utilize them to the fullest extent. The less lines of code you write the less lines there are to maintain.