Handler 实现 线程间通信

一、子 → 主线程通信

在主线程中, 实例Handler对象。

 1 Handler mHandler = new Handler(){
 2 @Override
 3    public  void handleMessage(Message msg) {
 4        super.handleMessage(msg);  
 5        switch (msg.what) {
 6        case 0:
 7          //do something, refresh UI …
 8          break;  
 9        default:  
10         break; 
11       }
12    }
13 };

main() -> looper.loop() -> messageQueue.next() -> hander.dispatchMessage -> handler.handleMessage()

在子线程中，发送消息给主线程。

1 new Thread() {
2    public void run() {
3        Message message = new Message();
4        message.obj = "子线程发送的消息";
5        mHandler.sendMessage(message);
6    };
7 }.start();

//消息入队列的过程
mHandler.sendMessage(msg) -> messageQueue.enqueueMessage()

handler子线程向主线程通信.png

二、子 → 子线程通信

在一个子线程中创建一个Handler，回调自然就在此子线程中，然后在另一个子线程中调用这个handler来发送消息。

 1 new Thread(new Runnable() {
 2  
 3    @Override
 4    public void run() {
 5          String msg;
 6          Looper.prepare();//⭐️
 7  
 8          childHandler = new Handler() {
 9            @Override
10            public void handleMessage(Message msg) {
11                 super.handleMessage(msg);
12  
13                 System.out.println("这是从--->>" + msg.obj+ "过来的消息");  
14                }  
15            };  
16           Looper.loop();//开始轮循⭐️
17      }
18   }).start();

然后创建第二个子线程

 1 new Thread(new Runnable() {
 2  
 3     @Override
 4     public void run() {
 5            Looper loop = Looper.myLooper();//⭐️
 6            Message msg = childHandler.obtainMessage();
 7            msg.obj = " 子线程 ";
 8            childHandler.sendMessage(msg);
 9      }
10  }).start();

三、主 → 子线程通信

需要在子线程初始化Looper，并在主线程里创建的Handler引用子线程的Looper
Handler中引用哪个线程的Looper，就在那个线程里处理消息。

public class ThreadHandlerActivity extends Activity{     
 2      //创建子线程
 3      class MyThread extends Thread{
 4         private Looper looper;//取出该子线程的Looper
 5         public void run() {
 6  
 7             Looper.prepare();//创建该子线程的Looper
 8             looper = Looper.myLooper();//取出该子线程的Looper
 9             Looper.loop();//只要调用了该方法才能不断循环取出消息
10         }
11      }
12  
13      private Handler mHandler;//将mHandler指定轮询的Looper
14  
15      protected void onCreate(Bundle savedInstanceState) {
16           super.onCreate(savedInstanceState);
17           setContentView(R.layout.main);

18          // thread = new MyThread();
19          // thread.start();//开启这个线程

             //实例化一个特殊的线程HandlerThread必须指定一个名字 （MyThread用不上了）
             HandlerThread thread = new HandlerThread("handlerThread");
             thread.start();//开启这个线程

20           //下面是主线程发送消息
21           mHandler = new Handler(thread.looper){//用18行，thread这里是空
22           public void handleMessage(android.os.Message msg) {
23               Log.d("当前子线程是----->",Thread.currentThread()+"");
24               };
25           };
26           mHandler.sendEmptyMessage(1);
27      }
28  }

HandlerThread 创建处理的子线程里是不能重写Run()方法的，因HandlerMessage本身实现了Run()方法

看一下内部实现：

 1 @Override
 2    public void run() {
 3       mTid = Process.myTid();
 4       Looper.prepare();
 5       synchronized (this) {
 6          mLooper = Looper.myLooper();
 7          notifyAll();
 8       }
 9      Process.setThreadPriority(mPriority);
10      onLooperPrepared();
11      Looper.loop();
12      mTid = -1;
13    }

**因自己各个项目穿插频繁，为了避免忘得干干净净，方便自己定期翻阅。