子线程和子线程之间的通信

1. package lib.com.myapplication;  
2.   
3. import android.os.Bundle;  
4.   
5. import android.os.Handler;  
6.   
7. import android.os.Looper;  
8.   
9. import android.os.Message;  
10.   
11. importandroid.support.v7.app.AppCompatActivity;  
12.   
13.    
14.   
15. public classMainActivity extendsAppCompatActivity {  
16.   
17.    
18.   
19.     privateHandler handler1 ;  
20.   
21.     privateHandler handler2 ;  
22.   
23.    
24.   
25.     @Override  
26.   
27.     protectedvoid onCreate(BundlesavedInstanceState) {  
28.   
29.         super.onCreate(savedInstanceState);  
30.   
31.         setContentView(R.layout.activity_main);  
32.   
33.         newMyThread1().start();  
34.   
35.         newMyThread2().start();  
36.   
37.     }  
38.   
39.    
40.   
41.     classMyThread1 extends Thread{  
42.   
43.    
44.   
45.         @Override  
46.   
47.         publicvoid run() {  
48.   
49.             super.run();  
50.   
51.    
52.   
53.             Looper.prepare();  
54.   
55.    
56.   
57.             handler1= new Handler(){  
58.   
59.                 @Override  
60.   
61.                 publicvoid handleMessage(Messagemsg) {  
62.   
63.                     super.handleMessage(msg);  
64.   
65.                     System.out.println("threadName--" +Thread.currentThread().getName() + "messageWhat-"+msg.what );  
66.   
67.                 }  
68.   
69.             };  
70.   
71.    
72.   
73.             try{  
74.   
75.                 sleep(3000 );  
76.   
77.             }catch (InterruptedException e) {  
78.   
79.                 e.printStackTrace();  
80.   
81.             }  
82.   
83.    
84.   
85.             handler2.sendEmptyMessage(2 ) ;  
86.   
87.    
88.   
89.             Looper.loop();  
90.   
91.         }  
92.   
93.     }  
94.   
95.    
96.   
97.     classMyThread2 extends Thread{  
98.   
99.         @Override  
100.   
101.         publicvoid run() {  
102.   
103.             super.run();  
104.   
105.             Looper.prepare();  
106.   
107.    
108.   
109.             handler2= new Handler(){  
110.   
111.                 @Override  
112.   
113.                 publicvoid handleMessage(Messagemsg) {  
114.   
115.                     super.handleMessage(msg);  
116.   
117.                     System.out.println("threadName--" +Thread.currentThread().getName() + "messageWhat-"+msg.what );  
118.   
119.                 }  
120.   
121.             };  
122.   
123.    
124.   
125.             try{  
126.   
127.                 sleep(4000 );  
128.   
129.             }catch (InterruptedException e) {  
130.   
131.                 e.printStackTrace();  
132.   
133.             }  
134.   
135.    
136.   
137.             handler1.sendEmptyMessage(5 ) ;  
138.   
139.    
140.   
141.             Looper.loop();  
142.   
143.         }  
144.   
145.     }  

　

注意：

1、调用Looper类的 prepare() 方法可以为当前线程创建一个消息循环，调用loop() 方法使之处理信息，直到循环结束。

2、Handler有几个构造重载，如果构造时不提供Looper类对象参数，会获取当前线程的Looper对象，即将当前线程的消息循环作为Handler关联的消息循环。

3、消息处理机制中，消息存放在一个消息队列中，而线程围绕这个队列进入一个无限循环，直到程序退出。如果队列中有消息，线程就会把消息取出来，并分发给相应的Handler进行处理；如果队列中没有消息，线程就会进入空闲等待状态，等待下一个消息的到来。