学完多线程技术，并了解了线程和CPU的运行原理。可以利用等待唤醒机制来控制线程得到或放弃CPU执行权。那么，不借助等待唤醒机制，我们是否也能实现对多线程的控制，达到相同效果呢？可能你会认为这是痴人说梦。但仔细看完下面的程序，希望能对多线程有更深的了解。

1. /*
   
2. 该例没有使用”等待唤醒“机制，却依然实现了多线程对同一资源进行操作的效果（当然效率比使用等待唤醒机制的时候要低）。
   
3. */
   
4. class Res
   
5. {
   
6. /*定义flag变量，用于标记生产者和消费者的
   
7. 动作交替。如果flag为true，生产者可以进行
   
8. ”生产“，消费者不能进行”消费“；反之，亦然。*/
   
9. private boolean flag=true;
   
10. 
    
11. /*定义mark变量，用于标记生产的内容。如果
    
12. mark为true，生产”张三“，如果mark为false，
    
13. 生产”rose“。*/
    
14. boolean mark = true;
    
15. 
    
16. /*定义count指针，用于给生产的信息编号*/
    
17. private int count = 1;
    
18. 
    
19. private String name;
    
20. private String sex;
    
21. 
    
22. 
    
23. //同步方法，用于生产者设置信息。
    
24. public synchronized void setInfo(String name, String sex)
    
25. {
    
26. /*首先判断flag标记。注：在flag为false的情况下，即使消费者线程得到
    
27. CPU执行权，也不会执行任何动作*/
    
28. if(flag)
    
29. {
    
30. this.name=name+(count++);
    
31. this.sex=sex;
    
32. System.out.println(Thread.currentThread().getName()+"——生产了："+this.name+"-----"+this.sex);
    
33. flag=false;//改变flag标记
    
34. mark=(mark==true)?false:true;//改变mark标记
    
35. }
    
36. }
    
37. //同步方法，用于消费者获取信息
    
38. public synchronized void getInfo()
    
39. {
    
40. /*首先判断flag标记。注：在flag为true的情况下，即使生产者线程得到
    
41. CPU执行权，也不会执行任何动作*/
    
42. if(!flag)
    
43. {
    
44. System.out.println(Thread.currentThread().getName()+"——消费了："+this.name+"-----"+this.sex);
    
45. flag=true;//改变flag标记
    
46. }
    
47. }
    
48. }
    
49. class Producer implements Runnable
    
50. {
    
51. private Res res;
    
52. 
    
53. public Producer(Res res)
    
54. {
    
55. this.res=res;
    
56. }
    
57. public void run()
    
58. {
    
59. while(true)
    
60. {
    
61. if(res.mark)//mark为true，生产”张三“
    
62. {
    
63. res.setInfo("张三", "男");
    
64. }
    
65. else//mark为false，生产”rose“
    
66. {
    
67. res.setInfo("rose", "female");
    
68. }
    
69. }
    
70. }
    
71. }
    
72. class Consumer implements Runnable
    
73. {
    
74. private Res res;
    
75. public Consumer(Res res)
    
76. {
    
77. this.res=res;
    
78. }
    
79. public void run()
    
80. {
    
81. while(true)//消费者消费”信息“
    
82. {
    
83. res.getInfo();
    
84. }
    
85. }
    
86. }
    
87. public class ThreadDemo02
    
88. {
    
89. public static void main(String args [])
    
90. {
    
91. Res res = new Res();
    
92. //创建两个生产者线程和两个消费者线程
    
93. Producer p1 = new Producer(res);
    
94. Producer p2 = new Producer(res);
    
95. Consumer c1 = new Consumer(res);
    
96. Consumer c2 = new Consumer(res);
    
97. 
    
98. new Thread(p1).start();
    
99. new Thread(p2).start();
    
100. new Thread(c1).start();
     
101. new Thread(c2).start();
     
102. }
     
103. }

复制代码

重点说明：
多线程对同一资源操作的问题中，有两点是至关重要的：
1）CPU工作原理：CPU是以极高的频率在多个线程之间做着快速的切换，并不是长时间只执行一个线程。
2）定义资源标记：这里说的“资源标记”就是boolean型变量，它的变化记录着该由哪些线程执行操作，哪些线程不该执行操作。
    该例中涉及到两个“资源标记”：flag和mark。flag用于记录该对资源进行生产操作还是消费操作的情况。mark用于记录该生产哪种类型的产品（“张三”或“rose ”）。
    只要定义好这两个“标记”，即使不借助等待唤醒机制，也可以实现多个生产者和多个消费者对同一资源进行操作的效果。

当然，这个程序的执行效率要低于加入等待唤醒机制的程序。因为正常程序中，线程遇到wait（）会释放执行资格。该程序中却不存在释放执行资格的情况，而是借助CPU的快速切换实现效果。
该例目的在于使大家明白，实现多线程对同一资源进行操作时，并不是必须要利用等待唤醒机制，只是一般程序都要提高效率，故等待唤醒这种机制会使用地比较普遍。
附执行效果图。期待交流。

顶一个。。。。

顶起，顶起！