Android 跨线程通信（Handler）

1.进程与线程

• 进程：android一般一个程序占有一个进程，但可以通过给四大组件指定android:process属性 开启单独，一个进程会运行在
• 线程： 在一个应用 中耗时操作一般要开启子线程去操作，也就是说一个进程可以有多个线程，它们之间是包含关系。
• 子进程和父进程有不同的代码和数据空间，而多个线程则共享数据空间，每个线程有自己的执行堆栈和程序计数器为其执行上下文。
• 进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。
• 进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。
• 线程间通信除了Handler这种外，还有其他几种方式：管道Pip、共享内存、通过文件及数据库等

2.通信

我们使用一个Handler进行通信，线程Ａ、B和C、D之间，只有一个可以接收消息并处理，另一个只能够发送。

多线程通信1.png

3.消息处理中的几大角色

图片引用地址：https://www.jianshu.com/p/7657f541c461

image

andriod提供了Handler和Looper来满足线程间的通信。Handler先进先出原则。Looper类用来管理特定线程内对象之间的消息交换

Message

• 线程间通信就是在传递消息，Message就是消息的载体。常用的有四个字段：arg1，arg2，what，obj。obj可以携带Object对象，其余三个可以携带整形数据。

MessageQueue

• MessageQueue是持有Message（在Looper中派发）的一个链表，Message并不是直接添加到MessageQueue中的，而是通过与Looper相关联的Handler来进行的。
• 用来存放线程放入的消息,读取会自动删除消息，单链表维护，在插入和删除上有优势。在其next()中会无限循环，不断判断是否有消息，有就返回这条消息并移除。

Looper

• 一个线程可以产生一个Looper对象，由它来管理此线程里的MessageQueue
• Looper创建的时候会创建一个MessageQueue，调用loop()方法的时候消息循环开始，loop()也是一个死循环，会不断调用messageQueue的next()，当有消息就处理，否则阻塞在messageQueue的next()中。当Looper的quit()被调用的时候会调用messageQueue的quit(),此时next()会返回null，然后loop()方法也跟着退出。
• MessageQueue和Looper是一对一关系，Handler和Looper是多对一
• 线程是默认没有Looper的，线程需要通过Looper.prepare()、绑定Handler到Looper对象、Looper.loop()来建立消息循环；在主线程，也就是ActivityThread，在被创建的时候就会初始化Looper，所以主线程中可以默认使用Handler

Handler

• 在主线程构造一个Handler，与Looper沟通，以便push新消息到MessageQueue里;
• 接收Looper从MessageQueue取出Handler所送来的消息。然后在其他线程调用sendMessage(),此时主线程的MessageQueue中会插入一条message，然后被Looper使用.
• 用于发送和处理消息的发送消息，一般使用sendMessage(),还有sendMessage的方法，但最终都是调用sendMessageAtTime()方法，除了sendMessageAtFrontOfQueue()这个方法。
• 只要在Looper线程（就是实现了Looper的线程）构建Handler类，那么这个Handler实例就获取该Looper线程MessageQueue实例的引用，Handler 在sendMessage()的时候就通过这个引用往消息队列里插入新消息。

Thread

• UIthread 通常就是main thread，而Android启动程序时会替它建立一个MessageQueue,系统的主线程在ActivityThread的main()为入口开启主线程，其中定义了一系列消息类型，包含四大组件的启动停止。

ThreadLocal

• ThreadLocal的作用是提供线程内的局部变量，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。引用 Android关于ThreadLocal的思考和总结

4.创建Handler的两种方式

一个是在主线程中创建

public class TestActivity extends AppCompatActivity {
        private static final String TAG = "TestActivity";
        private Handler mHandler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //获得发送Message对象，进行UI操作
                Log.e(TAG,"------------> msg.what = " + msg.what);
            }
        };

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_test);
            initThread();
        }

        private void initThread() {
            //开启线程处理耗时操作
            new Thread(new Runnable() {
                @Override
                public void run() {
                    SystemClock.sleep(2000);
                    //通过Handler发送消息切换回主线程（mHandler所在的线程）
                    mHandler.sendEmptyMessage(0);
                }
            }).start();
        }

• 一个是在普通工作线程中创建

public class TestActivity extends AppCompatActivity {
        private static final String TAG = "TestActivity";
        //主线程的Handler
        private Handler mHandler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //获得发送Message对象，进行UI操作
                Log.e(TAG,"------------> msg.what = " + msg.what);
            }
        };
        //子线程中的Handler
        private Handler mHandlerThread = null;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_test);
            initThread();
        }

        private void initThread() {
            //开启线程处理耗时的操作
            new Thread(new Runnable() {
                @Override
                public void run() {
                    SystemClock.sleep(2000);
                    //通过Handler发送消息切换回主线程（mHandler所在的线程）
                    mHandler.sendEmptyMessage(0);
                    //调用Looper.prepare()方法
                    Looper.prepare();
                    mHandlerThread = new Handler(){
                        @Override
                        public void handleMessage(Message msg) {
                            super.handleMessage(msg);
                            Log.e("sub thread","---------> msg.what = " + msg.what);
                        }
                    };
                    mHandlerThread.sendEmptyMessage(1);
                    //调用Looper.loop()方法
                   Looper.loop();
                }
            }).start();
        }
}

• 当Looper.prepare()执行之后，普通的工作线程就变成了Looper线程，该线程就可以接收并处理消息
• 而Looper.loop()方法就是进入一个无限循环，不断从MessageQueue中获取消息，当没有消息时就阻塞在那里
• Handler 对象在哪个线程下构建（构造函数在哪个线程下调用），那么Handler 就会持有该线程的Looper引用和消息队列的引用。这个Handler对象可在任意其他线程给该线程的消息队列添加消息，说明Handler的handlerMessage 也在该线程执行的。如果该线程不是Looper线程，在这个线程new Handler 就会报错！