多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。
等待唤醒机制所涉及到的方法：
wait（） :等待，将正在执行的线程释放其执行资格 和 执行权，并存储到线程池中。
notify（）：唤醒，唤醒线程池中被wait（）的线程，一次唤醒一个，而且是任意的。
notifyAll（）： 唤醒全部：可以将线程池中的所有wait() 线程都唤醒。
其实，所谓唤醒的意思就是让 线程池中的线程具备执行资格。必须注意的是，这些方法都是在 同步中才有效。同时这些方法在使用时必须标明所属锁，这样才可以明确出这些方法操作的到底是哪个锁上的线程。
仔细查看JavaAPI之后，发现这些方法 并不定义在 Thread中，也没定义在Runnable接口中，却被定义在了Object类中，为什么这些操作线程的方法定义在Object类中？
因为这些方法在使用时，必须要标明所属的锁，而锁又可以是任意对象。能被任意对象调用的方法一定定义在Object类中。
01.public class Resource {
02. private String name;
03. private int count = 1;
04. private boolean flag ;
05.
06. public synchronized void set(String name){
07. if(flag){
08. try {
09. this.wait();
10. } catch (InterruptedException e) {
11. // TODO Auto-generated catch block
12. e.printStackTrace();
13. }
14. }
15. this.name = name + count;
16. count++;
17.
18. System.out.println(Thread.currentThread().getName()
19. + "The producer name is :++++++++++++++ " + this.name);
20.
21. flag = true;
22.
23. this.notify();
24.
25. }
26.
27. public synchronized void out(){
28. if(!flag){
29. try {
30. this.wait();
31. } catch (InterruptedException e) {
32. // TODO Auto-generated catch block
33. e.printStackTrace();
34. }
35. }
36. System.out.println(Thread.currentThread().getName() +
37. "The consumer name is : ---------------------------" + this.name);
38. flag = false;
39.
40. this.notify();
41.
42. }
43.
44.}
45.
46.public class Producer implements Runnable {
47.
48. private Resource r;
49. public Producer(Resource r){
50. this.r = r;
51. }
52. @Override
53. public void run() {
54.
55. while(true){
56. r.set("馒头");
57. }
58.
59. }
60.}
61.
62.public class Consumer implements Runnable {
63.
64. private Resource r;
65. public Consumer(Resource r ){
66. this.r = r;
67. }
68. @Override
69. public void run() {
70.
71. while(true){
72. r.out();
73. }
74. }
75.}
76.
77.public class ProConDemo {
78.
79. public static void main(String[] args) {
80.
81. //资源对象
82. Resource r = new Resource();
83. //任务对象
84. Producer pro = new Producer(r);
85. Consumer con = new Consumer(r);
86. //线程对象，两个生产者，两个消费者
87. Thread t1 = new Thread(pro);
88. Thread t2 = new Thread(pro);
89.
90. Thread t3 = new Thread(con);
91. Thread t4 = new Thread(con);
92.
93. //开启线程
94. t1.start();
95. t2.start();
96. t3.start();
97. t4.start();
98. }
99.
100.}
经过分析，发现，产生这种状况的根源是：
1，本方唤醒了本方。
2，被唤醒的本方没有判断标记。
为此，我们要做的改进是——将if 判断改为 while 标记，保证，每次被wait的线程在醒了之后，都得再次判断标记。进过修改，再次运行之后，会发现新的问题又来了，产生了死锁。经过分析，这个问题的根源在于，本方唤醒了本方，被唤醒的本方判断标记后，发现，标记不成立，就继续等待，因此，再也没有活着的线程。为此，我们需要唤醒，所有的线程，就用到了 notifyAll() 。将线程池中，所有等待的线程都叫醒。
经过修改后的代码成功的解决了上述的问题。
01.public class Resource {
02. private String name;
03. private int count = 1;
04. private boolean flag ;
05.
06. public synchronized void set(String name){
07. //用while 确保线程醒了后再次，判断标记。
08. while(flag){
09. try {
10. this.wait();
11. } catch (InterruptedException e) {
12. // TODO Auto-generated catch block
13. e.printStackTrace();
14. }
15. }
16. this.name = name + count;
17. count++;
18.
19. System.out.println(Thread.currentThread().getName()
20. + "The producer name is :++++++++++++++ " + this.name);
21.
22. flag = true;
23. //唤醒所有被等待的线程
24. this.notifyAll();
25.
26. }
27.
28. public synchronized void out(){
29. //用while 确保线程醒了后再次，判断标记。
30. while(!flag){
31. try {
32. this.wait();
33. } catch (InterruptedException e) {
34. // TODO Auto-generated catch block
35. e.printStackTrace();
36. }
37. }
38. System.out.println(Thread.currentThread().getName() +
39. "The consumer name is : ---------------------------" + this.name);
40. flag = false;
41. //唤醒所有被等待的线程
42. this.notifyAll();
43.
44. }
45.}
Lock：比同步函数和同步代码块要好一些。同步函数还是同步代码块所做的都是隐式的锁操作。并且，同步函数或者同步代码块使用的锁和监视器是同一个。
Lock接口：是将锁进行单独对象的封装。而且提供了对锁对象很多功能。 比如：lock()获取锁，unlock()释放锁。 Lock对锁的操作都是显示操作。所以它的出现要比同步函数或者同步代码块明确的多，更符合面向对象思想。
简单一句话：Lock接口的出现替代同步。
01.class Resource
02.{
03.
04. private String name;
05. private int count = 1;
06. private boolean flag;
07. //创建一个锁对象。
08. private final Lock lock = new ReentrantLock();
09. //创建一个生产者的监视器。
10. private Condition producer_con = lock.newCondition();
11. //创建一个消费者监视器。
12. private Condition consumer_con = lock.newCondition();
13.
14. public void set(String name)//
15. {
16. //获取锁。
17. lock.lock();
18. try
19. {
20.
21. while(flag)
22. try{producer_con.await();}catch(InterruptedException e){}
23. this.name = name + count;
24.
25. count++;
26.
27. System.out.println(Thread.currentThread().getName()+".....生产者......"+this.name);
28. flag = true;
29. consumer_con.signal();
30. }
31. finally
32. {
33. //释放锁。
34. lock.unlock();
35. }
36. }
37.
38. public void get()//
39. {
40. lock.lock();
41. try
42. {
43.
44. while(!flag)
45. try{consumer_con.await();}catch(InterruptedException e){}
46.
47. System.out.println(Thread.currentThread().getName()+".........消费者......"+this.name);
48. flag = false;
49. producer_con.signal();
50. }
51. finally
52. {
53. lock.unlock();
54. }
55. }
56.}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
