Question

I have multiple threads printing data. All the data does print; however, they are not in order. Meaning Thread 2 starts printing while Thread 1 is not done yet, which causes inconsistency. How do I guarantee consistency ? Meaning Thread 2 can print once Thread 1 is done.

Answer 1

From your comments, you are looking to achieve 1 1 1 1 2 2 2 2 so what you’d need to do is actually wait for Thread1 to complete, then start Thread2, like this:

Thread1 thread1 = new Thread1();
Thread2 thread2 = new Thread2();

thread1.start();

thread1.join(); // This waits for Thread1 to finish before starting Thread2
thread2.start();

however, if you want to have both threads start, but have Thread2 wait part way through its processing, while waiting for Thread1 to complete – this can be done with a few techniques – one in particular comes to mind – using Semaphore.

Example:

Ok, firstly define your thread constructors to accept a Semaphore, thus:

// Thread2 would be identical wrt the semaphore
public Thread1(Semaphore semaphore) throws InterruptedException
{
  this.semaphore = semaphore; // store semaphore locally
  semaphore.acquire(2);
}

Thread1’s run method would look like this:

public void run()
{
  // .... processing...

  // ... print stuff
  System.out.println("1 1 1 1");
  semaphore.release(); // release 1 permit, allowing thread2 to continue

  // ... more processing

  semaphore.release(); // release last permit.
}

Thread2’s run method would look something akin to this:

public void run()
{
  int permits = 2;
  try
  {
    // .... processing...

    semaphore.acquire(1); // acquire one more permit (will block until Thread1 releases one)
    permits++;

    // ... print stuff
    System.out.println("2 2 2 2");

    // ... more processing      
  }
  catch (InterruptedException ie)
  {
    // interrupted
  }

  semaphore.release(permits); // release permits.
}

Now, setting up the threads would be done like this:

try
{
  Semaphore semaphore = new Semaphore(4); // 4 permit semaphore

  Thread1 thread1 = new Thread1(semaphore);
  Thread2 thread2 = new Thread2(semaphore);

  thread1.start();
  thread2.start();

  semaphore.acquire(4);
}
catch (InterruptedException ie)
{
  // interrupt logic...
}