Thread and Synchronization

[Buhi Mume]

      1 public class ThreadA {
      2
      3         public static void main(String[] args) {
      4
      5                 ThreadB b = new ThreadB();
      6                 b.start();
      7
      8                 synchronized(b) {
      9                         try {
     10                                 System.out.println("Waiting for b to complete...");
     11                                 b.wait();
     12                         }
     13                         catch (InterruptedException e) {
     14                                 System.out.println();
     15                         }
     16
     17                         System.out.println("Total is " + b.getTotal());
     18                 }
     19         }
     20 }
     21
     22 class ThreadB extends Thread {
     23
     24         int total;
     25
     26         public int getTotal() {
     27                 return total;
     28         }
     29
     30         public void run() {
     31
     32                 synchronized(this) {
     33                         for (int i = 1; i <= 5; i++)
     34                                 total += i;
     35
     36                         notify();
     37                 }
     38         }
     39 }

This code basically
1. runs Thread A, then waits until B completes
2. runs Thread B until completion, then notifies A to continue
3. continues Thread A until completion

I am trying to modify the code so that
1. runs Thread A, then waits until B completes
2. runs Thread B (half way), then notifies A to run, then waits until Thread B completes
3. continues Thread A until completion, then notifies B to continue
4. continues Thread B until completion

[Ernest Friedman-Hill]

Moving, not surprisingly, to "Threads and Synchronization."

[Promod kumar]

I am not sure if this will answer your question. Below is the code that does something similar where you have somestuff done in thread1 and then somestuff done in step2 and then back to thread1 etc. (There are some exceptions where the following will not work, in the case the notify() in Wait1 is triggered before wait() in Wait2.)

public class Wait2 {
 
/**
 * @param args
 */
public static void main(String[] args) {
 
Thread thread = new Wait1();
thread.start();
synchronized (thread) {
System.out.println("Line1");
try {
thread.wait();
} catch (InterruptedException e) {
 
e.printStackTrace();
}
System.out.println("Line3");
thread.notify();
try {
thread.wait();
} catch (InterruptedException e) {
 
e.printStackTrace();
}
System.out.println("Line5");
thread.notify();
try {
thread.wait();
} catch (InterruptedException e) {
 
e.printStackTrace();
}
System.out.println("Line7");
thread.notify();
try {
thread.wait();
} catch (InterruptedException e) {
 
e.printStackTrace();
}
System.out.println("Line9");
thread.notify();
 
}
}
}
 
public class Wait1 extends Thread {
 
public void run() {
synchronized (this) {
System.out.println("Line2");
notify();
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Line4");
notify();
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Line6");
notify();
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Line8");
notify();
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Line10");
 
}
}
 
}
 

Let me know if this helps or if there are any issues with this program. Experts, let me know if there is a better way of doing this.