Android消息机制 进程通信 线程通信

进程和线程的基本概念及两者之间的区别：
  进程：是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。
  线程：是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一些在运行中必不可少的资源(如程序计数器,一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。
  区别：
  （1）、一个程序至少有一个进程，一个进程至少有一个线程；
  （2）、线程的划分尺度小于进程，使得多线程程序的并发性高；
  （3）、进程在执行过程中拥有独立的内存单元，而多个线程共享内存，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉。

一、进程间通信方式

1.Bundle
  由于Activity，Service，Receiver都是可以通过Intent来携带Bundle传输数据的，所以我们可以在一个进程中通过Intent将携带数据的Bundle发送到另一个进程的组件。
  缺点：无法传输Bundle不支持的数据类型。

2.ContentProvider
  ContentProvider是Android四大组件之一，以表格的方式来储存数据，提供给外界，即Content Provider可以跨进程访问其他应用程序中的数据。用法是继承ContentProvider，实现onCreate,query,update,insert,delete和getType方法，onCreate是负责创建时做一些初始化的工作，增删查改的方法就是对数据的查询和修改，getType是返回一个String，表示Uri请求的类型。注册完后就可以使用ContentResolver去请求指定的Uri。

3.文件
  两个进程可以到同一个文件去交换数据，我们不仅可以保存文本文件，还可以将对象持久化到文件，从另一个文件恢复。要注意的是，当并发读/写时可能会出现并发的问题。

4.Broadcast
  Broadcast可以向android系统中所有应用程序发送广播，而需要跨进程通讯的应用程序可以监听这些广播。

5.AIDL方式
  Service和Content Provider类似，也可以访问其他应用程序中的数据，Content Provider返回的是Cursor对象，而Service返回的是Java对象，这种可以跨进程通讯的服务叫AIDL服务。   AIDL通过定义服务端暴露的接口，以提供给客户端来调用，AIDL使服务器可以并行处理，而Messenger封装了AIDL之后只能串行运行，所以Messenger一般用作消息传递。

6.Messenger
  Messenger是基于AIDL实现的，服务端（被动方）提供一个Service来处理客户端（主动方）连接，维护一个Handler来创建Messenger，在onBind时返回Messenger的binder。
  双方用Messenger来发送数据，用Handler来处理数据。Messenger处理数据依靠Handler，所以是串行的，也就是说，Handler接到多个message时，就要排队依次处理。

7.Socket
  Socket方法是通过网络来进行数据交换，注意的是要在子线程请求，不然会堵塞主线程。客户端和服务端建立连接之后即可不断传输数据，比较适合实时的数据传输

二、线程间通信方式

一般说线程间通信主要是指主线程（也叫UI线程）和子线程之间的通信，主要有以下两种方式：

1.AsyncTask机制
  AsyncTask，异步任务，也就是说在UI线程运行的时候，可以在后台的执行一些异步的操作；AsyncTask可以很容易且正确地使用UI线程，AsyncTask允许进行后台操作，并在不显示使用工作线程或Handler机制的情况下，将结果反馈给UI线程。但是AsyncTask只能用于短时间的操作（最多几秒就应该结束的操作），如果需要长时间运行在后台，就不适合使用AsyncTask了，只能去使用Java提供的其他API来实现。

2.Handler机制

Handler 是一个消息分发对象。handler是Android给我们提供用来更新UI的一套机制，也是一套消息处理机制，我们可以发消息，也可以通过它处理消息。根本的目的就是为了解决多线程并发的问题。

• 异步消息处理线程启动后会进入一个无限的循环体之中，每循环一次，从其内部的消息队列中取出一个消息，然后回调相应的消息处理函数，执行完成一个消息后则继续循环。若消息队列为空，线程则会阻塞等待。

• 那么Android消息机制主要是指Handler的运行机制，Handler运行需要底层的MessageQueue和Looper支撑。其中MessageQueue采用的是单链表的结构，Looper可以叫做消息循环。由于MessageQueue只是一个消息存储单元，不能去处理消息，而Looper就是专门来处理消息的，Looper会以无限循环的形式去查找是否有新消息，如果有的话，就处理，否则就一直等待着。

• 我们知道，Handler创建的时候会采用当前线程的Looper来构造消息循环系统，需要注意的是，线程默认是没有Looper的，如果需要使用Handler就必须为线程创建Looper，因为默认的UI主线程，也就是ActivityThread，ActivityThread被创建的时候就会初始化Looper，这也是在主线程中默认可以使用Handler的原因。

Handler类包含如下方法用于发送、处理消息：

• void handleMessage(Message msg)：处理消息的方法。该方法通常用于被重写。

• final boolean hasMessages(int what)：检查消息队列中是否包含what属性为指定值的消息。

• final boolean hasMessages(int what, Object object)：检查消息队列中是否包含what属性为指定值且object属性为指定对象的消息。

• 多个重载的Message obtainMessage()：获取消息。

• sendEmptyMessage(int what)：发送空消息。

• final boolean sendEmptyMessageDelayed(int what, long delayMillis)：指定多少毫秒后发送空消息。

• final boolean sendMessage(Message msg)：立即发送消息。

• final boolean sendMessageDelayed(Message msg, long delayMillis)：指定多少毫秒后发送消息。

• Message：Handler接收和处理的消息对象。

  • 2个整型数值：轻量级存储int类型的数据。
  • 1个Object：任意对象。
  • replyTo：线程通信时使用。
  • what：用户自定义的消息码，让接收者识别消息。

• MessageQueue：Message的队列。

  • 采用先进先出的方式管理Message。
  • 每一个线程最多可以拥有一个。

• Looper：消息泵，是MessageQueue的管理者，会不断从MessageQueue中取出消息，并将消息分给对应的Handler处理。

  • 每个线程只有一个Looper。
  • Looper.prepare()：为当前线程创建Looper对象。
  • Looper.myLooper()：可以获得当前线程的Looper对象。
  • Handler：能把消息发送给MessageQueue，并负责处理Looper分给它的消息。

首先再来简单总结一下整个消息机制的流程：
首先调用handler.sendMessage()将消息加入到MessageQueue中，

然后Looper通过MessageQueue.next()取出这条消息，

最后通过msg.target.dispatchMessage()又传递给了Handler来进行消息处理。

面试题：主线程中loop是一个死循环，为什么没有造成阻塞？

    首先 ActivityThread 并不是一个 Thread，就只是一个 final 类而已。我们常说的主线程就是从这个类的 main 方法开始

public static final void loop() {  
    Looper me = myLooper();  
    MessageQueue queue = me.mQueue;  
    // 开始了死循环
    while (true) {  
        Message msg = queue.next(); // might block  
        if (msg != null) {  
            if (msg.target == null) {  
                return;  
            }  
            if (me.mLogging!= null) me.mLogging.println(  
                    ">>>>> Dispatching to " + msg.target + " "  
                    + msg.callback + ": " + msg.what  
                    );  
            msg.target.dispatchMessage(msg);  
            if (me.mLogging!= null) me.mLogging.println(  
                    "<<<<< Finished to    " + msg.target + " "  
                    + msg.callback);  
            msg.recycle();  
        }  
    }  
}

 Activity 的生命周期都有对应的 case 条件了，ActivityThread 有个 getHandler 方法，得到这个 handler 就可以发送消息，然后 loop 里就分发消息，然后就发给 handler, 然后就执行到 H（Handler ）里的对应代码。所以这些代码就不会卡死～，有消息过来就能执行。举个例子，在 ActivityThread 里的内部类 ApplicationThread 中就有很多 sendMessage 的方法。
简单的来说：ActivityThread的main方法主要就是做消息循环，一旦退出消息循环，那么你的程序也就可以退出了。
从消息队列中取消息可能会阻塞，取到消息会做出相应的处理。如果某个消息处理时间过长，就可能会影响UI线程的刷新速率，造成卡顿的现象。

如果你了解下linux的epoll你就知道为什么不会被卡住了，先说结论：阻塞是有的，但是不会卡住
主要原因有2个

1. epoll模型
   当没有消息的时候会epoll.wait，等待句柄写的时候再唤醒，这个时候其实是阻塞的。

2. 所有的ui操作都通过handler来发消息操作。
   比如屏幕刷新16ms一个消息，你的各种点击事件，所以就会有句柄写操作，唤醒上文的wait操作，所以不会被卡死了。

以下几种情况都可能存在内存泄漏的情况

1.当一个Android应用启动的时候，会自动创建一个供应用主线程使用的Looper实例。Looper的主要工作就是一个一个处理消息队列中的消息对象。在Android中，所有Android框架的事件（比如Activity的生命周期方法调用和按钮点击等）都是放入到消息中，然后加入到Looper要处理的消息队列中，由Looper负责一条一条地进行处理。主线程中的Looper生命周期和当前应用一样长。

2.当一个Handler在主线程进行了初始化之后，我们发送一个target为这个Handler的消息到Looper处理的消息队列时，实际上已经发送的消息已经包含了一个Handler实例的引用，只有这样Looper在处理到这条消息时才可以调用Handler#handleMessage(Message)完成消息的正确处理。

3.在Java中，非静态的内部类和匿名内部类都会隐式地持有其外部类的引用。静态的内部类不会持有外部类的引用。

解决方式

• 要解决这种问题，思路就是不适用非静态内部类，继承Handler时，要么是放在单独的类文件中，要么就是使用静态内部类。因为静态的内部类不会持有外部类的引用，所以不会导致外部类实例的内存泄露。当你需要在静态内部类中调用外部的Activity时，我们可以使用弱引用来处理。另外关于同样也需要将Runnable设置为静态的成员属性。注意：一个静态的匿名内部类实例不会持有外部类的引用。

作者：AKyS佐毅
链接：https://www.jianshu.com/p/3855e0aa7900
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

三、Android两个子线程之间通信

  面试的过程中，有些面试官可能会问Android子线程之间的通信方式，由于绝大部分程序员主要关注的是Android主线程和子线程之间的通信，所以这个问题很容易让人懵逼。
  主线程和子线程之间的通信可以通过主线程中的handler把子线程中的message发给主线程中的looper，或者，主线程中的handler通过post向looper中发送一个runnable。但looper默认存在于main线程中，子线程中没有Looper，该怎么办呢？其实原理很简单，把looper绑定到子线程中，并且创建一个handler。在另一个线程中通过这个handler发送消息，就可以实现子线程之间的通信了。
  子线程创建handler的两种方式：
  方式一：给子线程创建Looper对象：

new Thread(new Runnable() {  
            public void run() {  
                Looper.prepare();  // 给这个Thread创建Looper对象，一个Thead只有一个Looper对象
                Handler handler = new Handler(){  
                    @Override  

                    public void handleMessage(Message msg) {  
                        Toast.makeText(getApplicationContext(), "handleMessage", Toast.LENGTH_LONG).show();  
                    }  
                };  
                handler.sendEmptyMessage(1);  
                Looper.loop(); // 不断遍历MessageQueue中是否有消息 
            };  
        }).start();  

  方式二：获取主线程的looper，或者说是UI线程的looper：

new Thread(new Runnable() {  
            public void run() {  
                Handler handler = new Handler(Looper.getMainLooper()){ // 区别在这！！！  
                    @Override  
                    public void handleMessage(Message msg) {  
                        Toast.makeText(getApplicationContext(), "handleMessage", Toast.LENGTH_LONG).show();  
                    }  
                };  
                handler.sendEmptyMessage(1);  
            };  
        }).start();