1、如何实现线程间的通讯。
最好给代码！！

自己理解~根据注释的思路走！

1. /*
   
2. * 绑票
   
3. * 垃圾筒
   
4. * 好人
   
5. * 坏人
   
6. */
   
7. public class ThreadDemo1 {
   
8.         public static void main(String[] args) {
   
9.                 LaJiTong ljt = new LaJiTong();
   
10.                 HaoRen haoRen = new HaoRen(ljt);
    
11.                 HuaiRen huaiRen = new HuaiRen(ljt);
    
12.                
    
13.                 huaiRen.start();
    
14.                 haoRen.start();
    
15.                
    
16.         }
    
17. }
    
18. 
    
19. /*
    
20. * 本类是好人类，它是一个线程！
    
21. * run()：向共享数据（垃圾筒）中存钱！
    
22. *
    
23. * 因为可能好人取钱的速度没有坏人快，坏人发现没有钱就撕票了！
    
24. * 如果坏人发现没钱，开始等待好人存钱，那么在好人存钱之后应该去唤醒坏人。
    
25. */
    
26. class HaoRen extends Thread {
    
27.         private LaJiTong ljt;
    
28.        
    
29.         public HaoRen(LaJiTong ljt) {
    
30.                 this.ljt = ljt;
    
31.         }
    
32.        
    
33.         public void run() {
    
34.                 synchronized (ljt) {
    
35.                         //存钱
    
36.                         System.out.println("好人：开始存钱！");
    
37.                         ljt.cun(500);
    
38.                         System.out.println("好人：存钱完毕！唤醒坏人!");
    
39.                         ljt.notify();
    
40.                         System.out.println("等待放人！");
    
41.                         try {
    
42.                                 Thread.sleep(5000);//sleep()是不会释放监视器对象的！
    
43.                         } catch (InterruptedException e) {
    
44.                         }
    
45.                 }
    
46.         }
    
47. }
    
48. 
    
49. /*
    
50. * 因为坏人有可能先去取钱，这时好人还没有存钱。
    
51. * 我们希望在坏人先取钱时，发现没有钱，应该等待好人存钱！
    
52. *
    
53. * 当好人存钱之后会唤醒坏人，然后坏人开始取钱！
    
54. */
    
55. class HuaiRen extends Thread {
    
56.         private LaJiTong ljt;
    
57.        
    
58.         public HuaiRen(LaJiTong ljt) {
    
59.                 this.ljt = ljt;
    
60.         }
    
61.        
    
62.         public void run() {
    
63.                 synchronized (ljt) {
    
64.                         //查看钱
    
65.                         // 如果没有钱：撕票！
    
66.                         // 如果有钱：取钱，放人！
    
67.                         int balance = ljt.cha();
    
68.                         System.out.println("坏人：查看余额！");
    
69.                         if(balance <= 0) {
    
70.                                 System.out.println("坏人：发现没钱，开始等待好人存钱！");
    
71.                                 try {
    
72.                                         ljt.wait();
    
73.                                 } catch (InterruptedException e) {
    
74.                                 }
    
75.                                 System.out.println("坏人：我被唤醒了，重新查看垃圾筒！");
    
76.                         }
    
77.                         if(ljt.cha() <= 0) {
    
78.                                 System.out.println("坏人：居然没有钱，撕票！");
    
79.                         } else {
    
80.                                 System.out.println("坏人：哇，好多钱啊，开始取钱！");
    
81.                                 ljt.qu();
    
82.                                 System.out.println("坏人：钱已取到，放人！");
    
83.                         }
    
84.                 }
    
85.         }
    
86. }
    
87. 
    
88. /*
    
89. * 垃圾筒类
    
90. * 它有一个属性是余额
    
91. * 有存、取、查三个方法
    
92. */
    
93. class LaJiTong {
    
94.         private int balance;
    
95.        
    
96.         public void cun(int balance) {
    
97.                 this.balance = balance;
    
98.         }
    
99.        
    
100.         public void qu() {
     
101.                 this.balance = 0;
     
102.         }
     
103.        
     
104.         public int cha() {
     
105.                 return this.balance;
     
106.         }
     
107. }

复制代码

线程之间通讯有几个关键字，举例子：join()  yield()  wait()  notify()等
另外还有判断线程是否活着啊，设置优先级等等。
他们之间通讯使用调用相应方法判断怎么执行和通讯的，具体请参照相应方法，
我这里给你举个简单例子，你可以看看，他说的是两个线程同时打印1-500，
这里加的yield()的意思是每当一个线程整除10的时候让另外的线程有机会执行。

1. public class TestThread extends Thread{
   
2.         public static void main(String[] args){
   
3.                 Runner r = new Runner();
   
4.                 r.start();
   
5.                
   
6.                 for(int i=0; i<=500; i++){
   
7.                         System.out.println("main:" + i);
   
8.                         if(i%10==0){yield();}
   
9.                 }
   
10.         }
    
11. }
    
12. 
    
13. class Runner extends Thread{
    
14.         public void run(){
    
15.                 for(int i=0; i<=500; i++){
    
16.                         System.out.println("Runner:" + i);
    
17.                         if(i%10==0){yield();}
    
18.                 }
    
19.         }
    
20. }

复制代码

希望能帮到你。。

拿走研究研究