Xtykutl

I am having trouble resolving this one thread waiting on another issue (even after viewing several questions posts). Here is what I am trying to do: I want one thread (called sub-thread) to print 10 times under outer-loop with 2 iterations; then another (boss-thread) to print 100 times under outer-loop with 2 iterations provided that sub-thread goes first. It will look something like this:

Sub Thread- iter = 1

Sub Thread- iter = 2

...

Sub Thread- iter = 10

Boss Thread- iter = 1

Boss Thread- iter = 2

...

Boss Thread- iter = 100

This sub-thread and boss-thread printing sequence will continue for 2 times (outer-loop).
My implementation has unpredicatable results, i.e. it prints out first iteration of sub-thread 10 times then halts there or it rarely prints out all statements and run through both the inner-loop and outer-loop. I use wait() and notify() to enable communication bewteen threads. I am not sure if I place synchronized block in the wrong place or I just mis-used the wait() and notify() pairs. Here's the code:

public class Main {



    public static void main(String args) {

        Main ic = new Main();



        Thread t1 = new Thread(ic.new Th1(), "Boss Thread-");

        Thread t2 = new Thread(ic.new Th2(), "Sub Thread-");



        t2.start();

        t1.start();

    }



    // Boss Thread

    private class Th1 implements Runnable {



        @Override

        public void run() {

            System.out.println("TH1 RUNS FIRST");

            synchronized (Main.class) { // lock outside of outer loop so

                                                        // boss thread can pick up the next iteration

                for (int i = 0; i < 2; i++) { 

                    // wait, let the sub-thread run first 

                    try {

                        Main.class.wait();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }



                    // print iterations 

                    for (int j = 0; j < 100; j++) {

                        System.out.println(Thread.currentThread().getName() + " iter = " + (j + 1));

                    }

                    System.out.println("end of boss outer----------------------" + (i + 1));

                    // wake up sub-thread and let it knows inner-iteration finished 

                    Main.class.notify();

                }

            }

        }

    }



    // Sub Thread

    private class Th2 implements Runnable {



        @Override

        public void run() { 

            for (int i = 0; i < 2; i++) {

                synchronized (Main.class) { // lock up Th2

                    // print iterations 

                    for (int j = 0; j < 10; j++) { 

                        System.out.println(Thread.currentThread().getName() + " iter = " + (j + 1)); 

                    }



                    // wake up other boss thread and let it know inner-iteration finished

                    Main.class.notify();



                    // wait for other thread to run

                    try {

                        Main.class.wait();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    System.out.println("end of Sub outer---------------------- " + (i + 1));

                }

            }

        }

    }

}

Extra assistance needed: would someone tell me if synchronized is a good way of locking shared resource or other better alternatives are out there? Say ReentrantLock? Also, are notify() and wait() a good means to implement inter-threads communication or there are better means to make this less error-prone and more efficient?

After some thoughts and efforts, I've come up with an "implementation" that "meets" my expectation as described in the question post. I have made some changes to the wait and notify pairs and added an isTh2RunFirst flag to assist the communication of the two threads. Here's the code:

public class InterThCom {

    // flag default to false for checking if sub-thread 

    // gets the lock first

    private boolean isTh2RunFirst = false; 



    public static void main(String args) {

        InterThCom itc = new InterThCom(); 



        Thread t1 = new Thread(itc.new Th1(), "Boss-thread-"); 

        Thread t2 = new Thread(itc.new Th2(), "Sub-thread-");



        t1.start();

        t2.start();

    }



    private class Th1 implements Runnable {



        @Override

        public void run() { 

            for (int i = 0; i < 2; i++) { 

                synchronized (InterThCom.class) { // lock up inner-loop



                    // boss-thread gets the lock first 

                    // wait for sub-thread and let it run;

                    // otherwise, skip this check

                    if (isTh2RunFirst == false) {

                        // wait for sub-thread, if boss-thread gets the lock first 

                        try {

                            InterThCom.class.wait();

                        } catch (InterruptedException e1) { 

                            e1.printStackTrace();

                        }

                    } 



                    // print iteration 100 times 

                    for (int j = 0; j < 100; j++) {

                        System.out.println(Thread.currentThread().getName() + " iter-" + (j + 1));

                    }

                    // done printing 100 times



                    // sub-thread should run already at this point 

                    isTh2RunFirst = true;



                    // This print helps split boss-th and sub-th prints

                    System.out.println(Thread.currentThread().getName() + " outer-loop iter:" + (i + 1));



                    // wake up sub-thread 

                    InterThCom.class.notify();



                    // wait for sub-thread 

                    try {

                        InterThCom.class.wait();

                    } catch (InterruptedException e) { 

                        e.printStackTrace();

                    } 

                } 

            }

        } 

    }



    private class Th2 implements Runnable {



        @Override

        public void run() {

            for (int i = 0; i < 2; i++) { 

                synchronized (InterThCom.class) {

                    // print iteration 10 times 

                    for (int j = 0; j < 10; j++) {

                        System.out.println(Thread.currentThread().getName() + " iter-" + (j + 1));

                    }

                    // done printing 10 times



                    // sub-thread already prints j iteration

                    isTh2RunFirst = true; 



                    // This print helps split boss-th and sub-th prints

                    System.out.println(Thread.currentThread().getName() + " outer-loop iter:" + (i + 1));



                    // wake up boss-thread 

                    InterThCom.class.notify();



                    // wait for boss-thread 

                    try {

                        InterThCom.class.wait();

                    } catch (InterruptedException e) { 

                        e.printStackTrace();

                    } 

                } 

            }

            synchronized (InterThCom.class) {

                // boss-thread is waiting at the last iteration, so wake it up

                InterThCom.class.notify();

            } 

        } 

    }



} 

I also posted a Code Review post if anyone feels like addressing to "proper" implementation (in terms of industry practices and efficiency) of thread-communication in detail for this specific case or others in general.