线程互斥与同步

能解决下面的问题，基本上就能理解线程互斥与同步了。

   子线程循环10次，主线程循环100次，接着子线程循环10，主线程循环100次。如此往复循环50次。

package cn.lah.thread;

public class TraditionalThreadCommunication {

    public static void main(String[] args) {

        final Business business = new Business();
        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i <= 50; i++) {
                    business.sub(i);
                }
            }
        }).start();

        for (int i = 1; i <= 50; i++) {
            business.main(i);
        }

    }

}

//定义一个业务逻辑类，将线程同步相关的方法归于本类，这种设计可以实现高内聚，并能增强代码的健壮性
class Business {

    private boolean beShouldSub = true;

    public synchronized void sub(int i) {
        while (!beShouldSub) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for (int j = 1; j <= 10; j++) {
            System.out.println("sub Thread" + j + " loop" + i);
        }
        beShouldSub = false;
        this.notify();
    }

    public synchronized void main(int i) {
        while (beShouldSub) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for (int j = 1; j <= 100; j++) {
            System.out.println("main Thread" + j + " loop" + i);
        }
        beShouldSub = true;
        this.notify();
    }
}

 另一个类似的面试题：

 有ABC三个线程，A线程输出A，B线程输出B，C线程输出C，如此循环往复10次。

 解法类似：

package cn.lah.thread;

public class ABCThreadTest {
   private static ABCThreadCommunication communication = new ABCThreadCommunication();
    public static void main(String[] args) {
       
        new Thread(new Runnable() {

            public void run() {
                for (int i = 1; i <= 10; i++) {
                    communication.showA(i);
                }

            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    communication.showB(i);
                }
            }
        }).start();

        new Thread(new Runnable() {

            public void run() {
                for (int i = 1; i <= 10; i++) {
                    communication.showC(i);
                }

            }
        }).start();

    }

}

class ABCThreadCommunication {
     private boolean beShouldA = true;
     private boolean beShouldB = false;
     private boolean beShouldC = false;
    public synchronized void showA(int i) {
        while(!beShouldA){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("A" + " loop " + i);
        beShouldA = false;
        beShouldB = true;
        this.notifyAll();
    }

    public synchronized void showB(int i) {
         while(!beShouldB){
             try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
         }
        System.out.println("B" + " loop " + i);
        beShouldB = false;
        beShouldC = true;
        this.notifyAll();
    }

    public synchronized void showC(int i) {
        while(!beShouldC){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("C" + " loop " + i);
        beShouldC = false;
        beShouldA = true;
        this.notifyAll();
    }
}