多线程——等待唤醒机制接着线程之间的通信， 这里有个问题， 同步了， 但是运行的话， 会执行一大片， 但是一般都是存一个，输出一个，
为什么会执行一大片？
一个线程可能一直拥有CPU的执行权；
如何解决？(参考代码)
这里可以用一个标记来标识（flag），当存一个完了之后， 就改变这个标识，当下次再执行时， 就不会再存了，
此时可以将这个线程1给冻结（sleep(时间（毫秒）)，wait（））,如果用sleep（），时间不确定， 所以就用wait(),当执行完了之后，
标识发生改变，再次执行时， 就处于冻结状态了，失去执行资格。
那什么时候恢复执行资格呢？
当另一个线程2进来将这个存的值，取走了， 就恢复执行资格，如何恢复？
当取走后， 标识再次发生改变，然后用notify()，唤醒线程1，此时如果这个线程2再次执行时， 由于没有了值， 那么就将线程2冻结，wait（）。
这个过程就是线程间的等待唤醒机制。
代码如下：

1. class Res //共享资源的类
   
2. {
   
3.         String name;
   
4.         String sex;
   
5.         boolean flag=false;
   
6. }
   
7. /*
   
8. 等待的线程在哪里呢？
   
9. 线程运行的时候， 内存中会建立一个叫做线程池的，等待线程都存放在线程池中，
   
10. 当notify的时候， 都是唤醒的是线程池中的线程，当线程池中有许多的线程都在等待，
    
11. 通常是唤醒第一被等待的线程， 按照顺序来叫醒
    
12. 
    
13. */
    
14. class Input implements Runnable//需要用到一个资源，
    
15. {
    
16.         private Res r;
    
17.         Input(Res r){//传递过来一个资源类的对象
    
18.                 this.r=r;
    
19.         }
    
20.         public void run(){
    
21.                 int x=0;
    
22.                 while(true)
    
23.                 {
    
24.                         synchronized(r)//这里需要同步，
    
25.                         {       
    
26.                                 if(r.flag){
    
27.                                         try{r.wait();}catch(Exception e){}//当为真时， 就等待， 不能再传值了，因为已经有值
    
28.                                 }
    
29.                                 if(x==0){
    
30.                                 r.name="mike";
    
31.                                 r.sex="man";
    
32.                         }
    
33.                                 else{
    
34.                                         r.name="小王";
    
35.                                         r.sex="女女女女女女";
    
36.                                 }
    
37.                                 x=(x+1)%2;
    
38.                                 r.flag=true;
    
39.                                 r.notify();//在线程池中叫醒Output线程
    
40.                         }
    
41.                 }
    
42.         }
    
43. }
    
44. class Output implements Runnable
    
45. {
    
46.         private Res r;
    
47.         Output(Res r){
    
48.                 this.r=r;
    
49.         }
    
50.         public void run(){
    
51.                 while(true)
    
52.                 {
    
53.                         synchronized(r){//这里也需要同步，并且锁需要是同一个锁。
    
54.                                 if(!r.flag){
    
55.                                         try{r.wait();}catch(Exception e){}
    
56.                                 }
    
57. //Wait()， notify()， notifyAll（）， 全部用在同步中，因为需要锁必须标识wait（）线程所处的锁
    
58.                                 System.out.println(r.name+"....."+r.sex);
    
59.                                 r.flag=false;
    
60.                                 r.notify();
    
61.                         }
    
62.                 }
    
63.         }
    
64. }
    
65. class ThreadInputOutput
    
66. {
    
67.         public static void main(String[] args)
    
68.         {
    
69.                 Res r=new Res();
    
70.                 Input in=new Input(r);
    
71.                 Output out=new Output(r);
    
72.                 Thread t1=new Thread(in);
    
73.                 Thread t2=new Thread(out);
    
74.                 t1.start();
    
75.                 t2.start();
    
76.         }
    
77. }
    

复制代码

多线程——等待唤醒机制接着线程之间的通信， 这里有个问题， 同步了， 但是运行的话， 会执行一大片， 但是一般都是存一个，输出一个，
为什么会执行一大片？
一个线程可能一直拥有CPU的执行权；
如何解决？(参考代码)
这里可以用一个标记来标识（flag），当存一个完了之后， 就改变这个标识，当下次再执行时， 就不会再存了，
此时可以将这个线程1给冻结（sleep(时间（毫秒）)，wait（））,如果用sleep（），时间不确定， 所以就用wait(),当执行完了之后，
标识发生改变，再次执行时， 就处于冻结状态了，失去执行资格。
那什么时候恢复执行资格呢？
当另一个线程2进来将这个存的值，取走了， 就恢复执行资格，如何恢复？
当取走后， 标识再次发生改变，然后用notify()，唤醒线程1，此时如果这个线程2再次执行时， 由于没有了值， 那么就将线程2冻结，wait（）。
这个过程就是线程间的等待唤醒机制。
代码如下：

1. class Res //共享资源的类
   
2. {
   
3.         String name;
   
4.         String sex;
   
5.         boolean flag=false;
   
6. }
   
7. /*
   
8. 等待的线程在哪里呢？
   
9. 线程运行的时候， 内存中会建立一个叫做线程池的，等待线程都存放在线程池中，
   
10. 当notify的时候， 都是唤醒的是线程池中的线程，当线程池中有许多的线程都在等待，
    
11. 通常是唤醒第一被等待的线程， 按照顺序来叫醒
    
12. 
    
13. */
    
14. class Input implements Runnable//需要用到一个资源，
    
15. {
    
16.         private Res r;
    
17.         Input(Res r){//传递过来一个资源类的对象
    
18.                 this.r=r;
    
19.         }
    
20.         public void run(){
    
21.                 int x=0;
    
22.                 while(true)
    
23.                 {
    
24.                         synchronized(r)//这里需要同步，
    
25.                         {       
    
26.                                 if(r.flag){
    
27.                                         try{r.wait();}catch(Exception e){}//当为真时， 就等待， 不能再传值了，因为已经有值
    
28.                                 }
    
29.                                 if(x==0){
    
30.                                 r.name="mike";
    
31.                                 r.sex="man";
    
32.                         }
    
33.                                 else{
    
34.                                         r.name="小王";
    
35.                                         r.sex="女女女女女女";
    
36.                                 }
    
37.                                 x=(x+1)%2;
    
38.                                 r.flag=true;
    
39.                                 r.notify();//在线程池中叫醒Output线程
    
40.                         }
    
41.                 }
    
42.         }
    
43. }
    
44. class Output implements Runnable
    
45. {
    
46.         private Res r;
    
47.         Output(Res r){
    
48.                 this.r=r;
    
49.         }
    
50.         public void run(){
    
51.                 while(true)
    
52.                 {
    
53.                         synchronized(r){//这里也需要同步，并且锁需要是同一个锁。
    
54.                                 if(!r.flag){
    
55.                                         try{r.wait();}catch(Exception e){}
    
56.                                 }
    
57. //Wait()， notify()， notifyAll（）， 全部用在同步中，因为需要锁必须标识wait（）线程所处的锁
    
58.                                 System.out.println(r.name+"....."+r.sex);
    
59.                                 r.flag=false;
    
60.                                 r.notify();
    
61.                         }
    
62.                 }
    
63.         }
    
64. }
    
65. class ThreadInputOutput
    
66. {
    
67.         public static void main(String[] args)
    
68.         {
    
69.                 Res r=new Res();
    
70.                 Input in=new Input(r);
    
71.                 Output out=new Output(r);
    
72.                 Thread t1=new Thread(in);
    
73.                 Thread t2=new Thread(out);
    
74.                 t1.start();
    
75.                 t2.start();
    
76.         }
    
77. }
    

复制代码