2个线程 循环打印ababab...

package mianshi.Thread;

/**
 * note： work类里面 实现互斥的 2个打印方法 A B。 2个线程各自调用A,B
 */
public class Work{
    volatile static boolean flag = true;

    public synchronized void printA() {
        System.out.println("AAAA");
        while (true) {
            if (!flag) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("a");
            flag = false;
            this.notifyAll();
        }
    }

    public synchronized void printB() {
        System.out.println("bbbb");
        while (true) {
            if (flag) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("b");
            flag = true;
            this.notifyAll();
        }
    }

    public void printC() {
        System.out.println("c");
    }

    public synchronized void printD() {
        System.out.println("d");
    }
}

 1 package mianshi.Thread;
 2 
 3 /**
 4  * 2个线程 循环打印 abab
 5  * 实现2：
 6  * note： 2个线程操作一个对象，主要是利用这个对象的 wait,notify,synchronize，然后 2个线程各自调用A,B
 7  */
 8 public class PrintAB {
 9     static boolean flag = true;
10 
11     public static void main(String[] args) {
12         PrintAB t = new PrintAB();
13 
14         new Thread(new Runnable() {
15             @Override
16             public void run() {
17                 synchronized (t) {
18                     while (true) {
19                         if (!flag) {
20                             try {
21                                 t.wait();
22                             } catch (InterruptedException e) {
23                                 e.printStackTrace();
24                             } finally {
25                             }
26                         }
27                         System.out.println("a");
28                         flag = false;
29                         t.notifyAll();
30                     }
31                 }
32             }
33         }).start();
34 
35         new Thread(new Runnable() {
36             @Override
37             public void run() {
38                 synchronized (t) {
39                     while (true) {
40                         if (flag) {
41                             try {
42                                 t.wait();
43                             } catch (InterruptedException e) {
44                                 e.printStackTrace();
45                             } finally {
46                             }
47                         }
48                         System.out.println("b");
49                         flag = true;
50                         t.notifyAll();
51                     }
52                 }
53             }
54         }).start();
55     }
56 }