这次弄得是线程间通信的问题。
里面有个什么等待\唤醒机制。哦哦
用东西是有条件的，
必这须得在同步里使用,因为使用到的方法是对线程进行的操作，是锁调用这些方法。
一定要明确是哪个锁的线程。

下面是看完米老爷视频打的代码，期间还出过错，不过总算是调好了

1. package com.itheima.Thread;
   
2. /**
   
3. * 线程间间通信演示事例
   
4. *
   
5. * 多个线程操作相同的资源，但是线程的任务是不同的。
   
6. *
   
7. * 解决安全问题，线程需要加锁而且需要加通一把锁
   
8. * @author DELL
   
9. *
   
10. * 等待/唤醒机制
    
11. * 必须在同步中使用，因为这些方法都是锁的方法，都是用来操作线程状态的。
    
12. * 必须要明确是哪个锁
    
13. *
    
14. */
    
15. public class CommnicateDemo {
    
16.         public static void main(String[] args) {
    
17.                 Resource r = new Resource();//只实例化一个资源，供给多个线程共享
    
18.                 new Thread(new Input(r)).start();
    
19.                 new Thread(new Output(r)).start();
    
20.         }
    
21. }
    
22. 
    
23. 
    
24. /**
    
25. * 多个线程处理的资源
    
26. */
    
27. class Resource{
    
28.         private String name;
    
29.         private String sex;
    
30.         boolean flag = false;
    
31.         public synchronized void set(String name,String sex){
    
32.                 if(this.flag){
    
33.                         try{
    
34.                                 this.wait();
    
35.                         }catch(InterruptedException e){
    
36.                                 e.printStackTrace();
    
37.                         }
    
38.                 }
    
39.                 this.name= name;
    
40.                 this.sex = sex;
    
41.                 this.flag = true;//本线程再执行会被冻结
    
42.                 this.notify();//唤醒其他线程
    
43.         }
    
44.         public synchronized void out(){
    
45.                 if(!this.flag){
    
46.                         try{
    
47.                                 this.wait();
    
48.                         }catch(InterruptedException e){
    
49.                                 e.printStackTrace();
    
50.                         }
    
51.                 }
    
52.                 System.out.println(this.name+"-----------------"+this.sex);
    
53.                 this.flag = false;
    
54.                 this.notify();
    
55.         }
    
56.        
    
57.        
    
58. }
    
59. 
    
60. /**
    
61. * 负责写入信息的线程
    
62. * @author DELL
    
63. *
    
64. */
    
65. class Input implements Runnable{
    
66.         private Resource r;
    
67.         Input(Resource r){//传入线程共用资源
    
68.                 this.r = r;
    
69.         }
    
70.         public void run(){
    
71.                 int x = 0;
    
72.                 while(true){
    
73.                         synchronized(r){
    
74.                                 if(x % 2 == 0){
    
75.                                         this.r.set("zhansan","nan");
    
76.                                 }else{
    
77.                                         this.r.set("丽丽","女女女女女女呢");
    
78.                                 }
    
79.                         }
    
80.                         x++;
    
81.                 }
    
82.         }
    
83. }
    
84. 
    
85. /**
    
86. * 负责打印信息的线程
    
87. * @author DELL
    
88. *
    
89. */
    
90. class Output implements Runnable{
    
91.         private Resource r;
    
92.         Output(Resource r){
    
93.                 this.r = r;
    
94.         }
    
95.         public void run(){
    
96.                 while(true){
    
97.                         this.r.out();
    
98.                 }
    
99.         }
    
100. }

复制代码

不容易呀，大家觉得多线程这东东要怎么学啊。什么项目里会用到多线程啊，不知道要在哪里使用。

我觉的这多线程就像个厕所，用到公用的内容的时候就用到它