//设置2个线程，t1,t2
//设置一个标记，flag＝1；执行到t1的时候判断flag＝＝1，成立就执行－－操作，修改flag＝0并this.notify唤醒其他线程
//不成立就执行wait()方法进入等待状态,执行到t2的时候判断flag是否为0，为0就执行－－操作，修改flag=1并this.notify唤醒其他线程
//由于flag初始值为1，所以t1会先执行，然后t1,t2交替执行

1. package com.itheima;
   
2. 
   
3. public class Text24 {
   
4.         // static int num = 100;
   
5. 
   
6.         public static void main(String[] args) throws Exception {
   
7.                 final Printer p = new Printer();
   
8. 
   
9.                 new Thread() {
   
10. 
    
11.                         public void run() {
    
12.                                 while (true) {
    
13.                                         try {
    
14.                                                 p.print1();
    
15. 
    
16.                                         } catch (Exception e) {
    
17. 
    
18.                                                 e.printStackTrace();
    
19.                                         }
    
20.                                 }
    
21.                         }
    
22.                 }.start();
    
23. 
    
24.                 new Thread() {
    
25. 
    
26.                         public void run() {
    
27.                                 while (true) {
    
28.                                         try {
    
29.                                                 p.print2();
    
30. 
    
31.                                         } catch (Exception e) {
    
32. 
    
33.                                                 e.printStackTrace();
    
34.                                         }
    
35.                                 }
    
36.                         }
    
37.                 }.start();
    
38. 
    
39.         }
    
40. 
    
41.         static class Printer {
    
42.                 private int flag = 1;
    
43.                 private int num = 1;
    
44. 
    
45.                 public void print1() throws Exception {
    
46.                         while (true) {
    
47.                                 synchronized (this) {
    
48.                                         Thread.sleep(1000);
    
49.                                         if (flag != 1) {
    
50.                                                 this.wait();
    
51.                                         }
    
52.                                         // if (num > 100) {
    
53.                                         // break;
    
54.                                         // }
    
55.                                         System.out.println("A线程打印" + num++);
    
56.                                         flag = 2;
    
57.                                         this.notify();
    
58.                                 }
    
59.                         }
    
60.                 }
    
61. 
    
62.                 public void print2() throws Exception {
    
63.                         while (true) {
    
64.                                  synchronized (this) {
    
65.                                 Thread.sleep(1000);
    
66.                                 if (flag != 2) {
    
67.                                         this.wait();
    
68.                                 }
    
69.                                 // if (num > 100) {
    
70.                                 // break;
    
71.                                 // }
    
72.                                 System.out.println("B线程打印" + num++);
    
73.                                 flag = 1;
    
74.                                 this.notify();
    
75.                                  }
    
76.                         }
    
77.                 }
    
78. 
    
79.         }
    
80. }
    

复制代码

谢谢分享