Question on Threads

[Arjun Reddy]

Hi All,

I am basically creating two threads and giving both the threads, the same job. Now in the run method, I am checking the thread name and joining it to another thread. But I am getting errors. Can someone tell me why? Also, since I am using a synchronized block in the run method and since join keeps the lock, I believe even if I succeed with the compilation process, it will cause a deadlock. Because say if thread t1 entered the run method and I do, t2.join, then t1 is waiting for t2 to complete but has the lock and t2 is waiting for the lock. Am I correct? I am providing the code.

package com.certificationpractice.threads;
 
public class SynchronizedBlockTest implements Runnable {
 
 public void run()
{
synchronized(this)
{
for(int i=1;i<=10;i++)
{

try {
if(Thread.currentThread()==Thread1)
{
Thread2.join();
}

else if(Thread.currentThread()==Thread2)
{
Thread1.join();
}

} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}

}
}

public static void main(String args[])
{
SynchronizedBlockTest job = new SynchronizedBlockTest();
Thread t1 = new Thread(job,"Thread1");
t1.start();

Thread t2 = new Thread(job,"Thread2");
t2.start();

}

}

1). Why won't the above code compile?
2). Am I correct that if the code would have compiled, it would lead to a deadlock?
3). How can I call join on t1 from t2 or join on t2 from t1 without causing a deadlock in the above situation?

Thanks.
[ September 15, 2008: Message edited by: Arjun Reddy ]

[Jamie MacDonald]

Your code won't compile because Thread1 and Thread2 in your run() method have not been declared. The following code will compile (and that's about all it's good for):

public class SynchronizedBlockTest implements Runnable {
  
  Thread Thread1;
  Thread Thread2;
 
  public void run() {
    synchronized (this) {
      for (int i = 1; i <= 10; i++) {
 
        try {
          if (Thread.currentThread() == Thread1) {
            System.out.println("Thread1 waiting to join Thread2");
            Thread2.join();
            System.out.println("Successfully joined with Thread2");
          } else if (Thread.currentThread() == Thread2) {
            System.out.println("Thread2 waiting to join Thread1");
            Thread1.join();
            System.out.println("Successfully joined with Thread1");
          }
 
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
      }
 
    }
  }
 
  public static void main(String args[]) {
    SynchronizedBlockTest job = new SynchronizedBlockTest();
    job.Thread1 = new Thread(job, "Thread1");
    job.Thread2 = new Thread(job, "Thread2");
 
    job.Thread1.start();
    job.Thread2.start();
  }
}

As you noted, once one of the Threads attempts to join with the other, you will wait forever. You don't actually even need the synchronized block to create the deadlock condition--if you remove it, then each Thread will get to the join statement and then wait forever for the other Thread to complete.

I'm not clear what the goal of your code is once it actually does something, but join() is typically used when you want a Thread to complete before something else happens. So you would put the join outside the run method:

  public static void main(String args[]) {
    SynchronizedBlockTest job = new SynchronizedBlockTest();
    job.Thread1 = new Thread(job, "Thread1");
    job.Thread2 = new Thread(job, "Thread2");
    job.Thread2.start();
    job.Thread1.start();
 
    try {
      job.Thread1.join();
      job.Thread2.join();
    } catch (Exception exception) {
      exception.printStackTrace();
    }
    // now do stuff that had Thread1 and Thread 2 as a prerequisite
  }

If you want two run() methods to be cooperating (for instance a Thread that gets user input and a Thread that processes it), you should use wait() and notify() to allow one to wait on the other while both are still active.