本篇文章针对向ServiceManager注册服务 和 获取服务两个流程来做总结。在这两个过程中，ServiceManager都扮演的是服务端，与客户端之间的通信也是通过Binder IPC。
让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：国际域名空间、网页空间、营销软件、网站建设、泰来网站维护、网站推广。
在此之前先了解下Binder的进程与线程的关系：
用户空间 :ProcessState描述一个进程，IPCThreadState对应一个进程中的一个线程。
内核空间 ：binder_proc描述一个进程，统一由binder_procs全局链表保存，binder_thread对应进程的一个线程。
ProcessState与binder_proc是一一对应的。
Binder线程池 ：每个Server进程在启动时会创建一个binder线程池，并向其中注册一个Binder线程；之后Server进程也可以向binder线程池注册新的线程，或者Binder驱动在探测到没有空闲binder线程时会主动向Server进程注册新的的binder线程。对于一个Server进程有一个最大Binder线程数限制15，(#define DEFAULT_MAX_BINDER_THREADS 15)。对于所有Client端进程的binder请求都是交由Server端进程的binder线程来处理的。我的理解是：binder线程是进程进行binder ipc时的一条数据处理路径。
MediaPlayerService向ServiceManager注册过程如下：
相关类：
整个过程总结如下：
1 获取BpServiceManager 与 BpBinder
由defaultServiceManager()返回的是BpServiceManager，同时会创建ProcessState对象和BpBinder对象。然后通过BpBinder执行transact，把真正工作交给IPCThreadState来处理。
2 BpBinder transact
Binder代理类调用transact()方法，真正工作还是交给IPCThreadState来进行transact工作。
3 通过IPCThreadState 包装并转换数据并进行transact事务处理
每个线程都有一个IPCThreadState，每个IPCThreadState中都有一对Parcel变量：mIn、mOut。相当于两根数据管道：
最后执行talkWithDriver。
writeTransactionData：将BC Protocol + binder_transaction_data结构体 写入mOut， 然后执行waitForResponse：
由talkWithDriver将数据进一步封装到binder_write_read结构体，通过ioctl（BINDER_WRITE_READ）与驱动通信。同时等待驱动返回的接收BR命令，从mIn取出返回的数据。
mIn包装的数据结构(注册服务handle = 0 ，code 为ADD_SERVICE_TRANSACTION)：
4 Binder Driver
把binder_write_read结构体write_buffer里数据取出来，分别得到BC命令和封装好数据的事务binder_transaction_data, 然后根据handler，在当前binder_proc中，找到相应的binder_ref，由binder_ref再找到目标binder_node实体，由目标binder_node再找到目标进程binder_proc。然后就是插入数据：当binder驱动可以找到合适的线程，就会把binder_transaction节点插入到servciemanager的线程的todo队列中，如果找不到合适的线程，就把节点之间插入servciemanager的binder_proc的todo队列。
5 ServiceManager
经过Binder Driver的处理，数据已经到了ServiceManager进程，在BR_TRANSACTION的引导下，在binder_loop（）中执行binder_parser（）取出数据，执行do_add_service（）操作，最终向 svcinfo 列表中添加已经注册的服务（没有数据的返回）。最后发送 BR_REPLY 命令唤醒等待的线程，通知注册成功。结束MediaPlayerService进程 waitForResponse()的状态，整个注册过程结束。
获取服务的过程与注册类似，首先 ServiceManager 向 Binder 驱动发送 BC_TRANSACTION 命令携带 CHECK_SERVICE_TRANSACTION 命令，同时获取服务的线程进入等待状态 waitForResponse()。Binder 驱动收到请求命令向 ServiceManager 的发送 BC_TRANSACTION 查询已注册的服务，会区分请求服务所属进程情况。
查询到直接响应 BR_REPLY 唤醒等待的线程。若查询不到将与 binder_procs 链表中的服务进行一次通讯再响应。
以startService为例来简单总结下执行流程：
3.1 从方法执行流程来看：
Client ：
1 AMP.startService 标记方法以及通过Parcel包装数据；
2 BinderProxy.transact 实际调用native的 android_os_BinderProxy_transact 传递数据；
3 获取BpServiceManager 与 BpBinder 同时会创建ProcessState。然后通过BpBinder执行transact，把真正工作交给IPCThreadState来处理；
4 IPC.transact 主要执行writeTransactionData，将上层传来的数据重新包装成binder_transaction_data，并将BC Protocol + binder_transaction_data结构体 写入mOut；
5 IPC waitForResponse talkWithDriver + 等待返回数据；
6 talkWithDriver 将数据进一步封装成binder_write_read，通过ioctl（BINDER_WRITE_READ）与驱动通信；
Kernel :
7 binder ioctl 接收BINDER_WRITE_READ ioctl命令；
8 binder_ioctl_write_read 把用户空间数据ubuf拷贝到内核空间bwr；
9 binder_thread_write 当bwr写缓存有数据，则执行binder_thread_write；当写失败则将bwr数据写回用户空间并退出；
10 binder_transaction 找到目标进程binder_proc并插入数据到目标进程的线程todo队列，最终执行到它
时，将发起端数据拷贝到接收端进程的buffer结构体；
11 binder_thread_read 根据binder_transaction结构体和binder_buffer结构体数据生成新的binder_transaction_data结构体，写入bwr的read_buffer，当bwr读缓存有数据，则执行binder_thread_read；当读失败则再将bwr数据写回用户空间并退出；最后，把内核数据bwr拷贝到用户空间ubuf。
12 binder_thread_write + binder_ioctl BR命令和数据传递
Server:
13 IPC.executeCommand 解析kernel传过来的binder_transaction_data数据，找到目标BBinder并调用其transact()方法;
14 IPC.joinThreadPool 采用循环不断地执行getAndExecuteCommand()方法, 处理事务。当bwr的读写buffer都没有数据时,则阻塞在binder_thread_read的wait_event过程. 另外,正常情况下binder线程一旦创建则不会退出.
15 BBinder.transact 到Binder.exeTransact 调用 AMN.onTransact
16 AMN.onTransact 把数据传递到AMS.starService去执行
17 AMS.starService Server处理了Client的请求了
然后原路replay回去，talkWithDriver 到Kernel ，然后找到Client进程，把数据拷贝到read_buffer里，最终唤醒IPC，把反馈传递回AMP.startService。完成启动服务。
3.2 从通信协议流程来看：
非oneWay:
oneway:
oneway与非oneway区别: 都是需要等待Binder Driver的回应消息BR_TRANSACTION_COMPLETE. 主要区别在于oneway的通信收到BR_TRANSACTION_COMPLETE则返回,而不会再等待BR_REPLY消息的到来. 另外，oneway的binder IPC则接收端无法获取对方的pid.
3.3 从数据流来看
从用户空间开始：
进入驱动后：
回到用户空间：
参考：
进程：是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。
线程：是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一些在运行中必不可少的资源(如程序计数器,一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。
区别：
（1）、一个程序至少有一个进程，一个进程至少有一个线程；
（2）、线程的划分尺度小于进程，使得多线程程序的并发性高；
（3）、进程在执行过程中拥有独立的内存单元，而多个线程共享内存，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉。
---------------------
一、Android进程间通信方式
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方法是通过网络来进行数据交换，注意的是要在子线程请求，不然会堵塞主线程。客户端和服务端建立连接之后即可不断传输数据，比较适合实时的数据传输
二、Android线程间通信方式
一般说线程间通信主要是指主线程（也叫UI线程）和子线程之间的通信，主要有以下两种方式：
1.AsyncTask机制
AsyncTask，异步任务，也就是说在UI线程运行的时候，可以在后台的执行一些异步的操作；AsyncTask可以很容易且正确地使用UI线程，AsyncTask允许进行后台操作，并在不显示使用工作线程或Handler机制的情况下，将结果反馈给UI线程。但是AsyncTask只能用于短时间的操作（最多几秒就应该结束的操作），如果需要长时间运行在后台，就不适合使用AsyncTask了，只能去使用Java提供的其他API来实现。
2.Handler机制
Handler，继承自Object类，用来发送和处理Message对象或Runnable对象；Handler在创建时会与当前所在的线程的Looper对象相关联(如果当前线程的Looper为空或不存在，则会抛出异常，此时需要在线程中主动调用Looper.prepare()来创建一个Looper对象)。使用Handler的主要作用就是在后面的过程中发送和处理Message对象和让其他的线程完成某一个动作（如在工作线程中通过Handler对象发送一个Message对象，让UI线程进行UI的更新，然后UI线程就会在MessageQueue中得到这个Message对象（取出Message对象是由其相关联的Looper对象完成的），并作出相应的响应）。
三、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();
---------------------
异步通信机制，将工作线程中需更新UI的操作信息 传递到 UI主线程，从而实现 工作线程对UI的更新处理，最终实现异步消息的处理。Handler不仅仅能将子线程的数据传递给主线程，它能实现任意两个线程的数据传递。
（1）Message
Message 可以在线程之间传递消息。可以在它的内部携带少量数据，用于在不同线程之间进行数据交换。除了 what 字段，还可以使用 arg1 和 arg2 来携带整型数据，使用 obj 来携带 Object 数据。
（2） Handler
Handler 作为处理中心，用于发送（sendMessage 系列方法）与处理消息（handleMessage 方法）。
（3） MessageQueue
MessageQueue 用于存放所有通过 Handler 发送的消息。这部分消息会一直存放在消息队列中，直到被处理。每个线程中只会有一个 MessageQueue 对象
（4） Looper
Looper 用于管理 MessageQueue 队列，Looper对象通过loop()方法开启了一个死循环——for (;;)｛｝，不断地从looper内的MessageQueue中取出Message，并传递到 Handler 的 handleMessage() 方法中。每个线程中只会有一个 Looper 对象。
AsyncTask 是一种轻量级的任务异步类，可以在后台子线程执行任务，且将执行进度及执行结果传递给 UI 线程。
（1）onPreExecute()
在 UI 线程上工作，在任务执行 doInBackground() 之前调用。此步骤通常用于设置任务，例如在用户界面中显示进度条。
（2）doInBackground(Params... params)
在子线程中工作，在 onPreExecute() 方法结束后执行，这一步被用于在后台执行长时间的任务，Params 参数通过 execute(Params) 方法被传递到此方法中。任务执行结束后，将结果传递给 onPostExecute(Result) 方法，同时我们可以通过 publishProgress(Progress) 方法，将执行进度发送给 onProgressUpdate(Progress) 方法。
（3）onProgressUpdate(Progress... values)
在 UI 线程上工作，会在 doInBackground() 中调用 publishProgress(Progress) 方法后执行，此方法用于在后台计算仍在执行时(也就是 doInBackgound() 还在执行时)将计算执行进度通过 UI 显示出来。例如，可以通过动画进度条或显示文本字段中的日志，从而方便用户知道后台任务执行的进度。
（4）onPostExecute(Result result)
在 UI 线程上工作，在任务执行完毕（即 doInBackground(Result) 执行完毕）并将执行结果传过来的时候工作。
使用规则：
（1）AsyncTask 是个抽象类，所以要创建它的子类实现抽象方法
（1）AsyncTask 类必须是在 UI 线程中被加载，但在Android 4.1（API 16）开始，就能被自动加载完成。
（2）AsyncTask 类的实例对象必须在 UI 线程中被创建。
（3）execute() 方法必须是在 UI 线程中被调用。
（4）不要手动调用方法 onPreExecute()、onPostExecute()、doInBackground()、onProgressUpdate()
（5）任务只能执行一次(如果尝试第二次执行，将抛出异常)。即一个AsyncTask对象只能调用一次execute()方法。
原理：
其源码中原理还是 Thread 与 Handler 的实现，其包含 两个线程池，一个 Handler，如下所示：
名称类型作用
SERIAL_EXECUTOR线程池分发任务，串行分发，一次只分发一个任务
THREAD_POOL_EXECUTOR线程池执行任务，并行执行，执行的任务由 SERIAL_EXECUTOR 分发
InternalHandlerHandler负责子线程与主线程的沟通，通知主线程做 UI 工作
一方面减少了每个并行任务独自建立线程的开销，另一方面可以管理多个并发线程的公共资源，从而提高了多线程的效率。所以ThreadPoolExecutor比较适合一组任务的执行。Executors利用工厂模式对ThreadPoolExecutor进行了封装。
Executors提供了四种创建ExecutorService的方法，他们的使用场景如下：
1. Executors.newFixedThreadPool()
创建一个定长的线程池，每提交一个任务就创建一个线程，直到达到池的最大长度，这时线程池会保持长度不再变化。
当线程处于空闲状态时，它们并不会被回收，除非线程池被关闭。当所有的线程都处于活动状态时，新任务都会处于等待状态，直到有线程空闲出来。
只有核心线程并且不会被回收，能够更加快速的响应外界的请求。
2. Executors.newCachedThreadPool()
创建一个可缓存的线程池，如果当前线程池的长度超过了处理的需要时，它可以灵活的回收空闲的线程，当需要增加时，它可以灵活的添加新的线程，而不会对池的长度作任何限制
线程数量不定的线程池，只有非核心线程，最大线程数为 Integer.MAX_VALUE。当线程池中的线程都处于活动状态时，线程池会创建新的线程来处理新任务，否则利用空闲的线程来处理新任务。线程池中的空闲线程具有超时机制，为 60s。
任务队列相当于一个空集合，导致任何任务都会立即被执行，适合执行大量耗时较少的任务。当整个线程池都处于限制状态时，线程池中的线程都会超时而被停止。
3. Executors.newScheduledThreadPool()
创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer。
非核心线程数没有限制，并且非核心线程闲置的时候立即回收，主要用于执行定时任务和具有固定周期的重复任务。
4. Executors.newSingleThreadExecutor()
创建一个单线程化的executor，它只创建唯一的worker线程来执行任务
只有一个核心线程，保证所有的任务都在一个线程中顺序执行，意义在于不需要处理线程同步的问题。
一般用于执行后台耗时任务，当任务执行完成会自动停止；同时由于它是一个服务，优先级要远远高于线程，更不容易被系统杀死，因此比较适合执行一些高优先级的后台任务。
使用步骤：创建IntentService的子类，重写onHandleIntent方法，在onHandleIntent中执行耗时任务
原理：在源码实现上，IntentService封装了HandlerThread和Handler。onHandleIntent方法结束后会调用IntentService的stopSelf(int startId)方法尝试停止服务。
IntentService的内部是通过消息的方式请求HandlerThread执行任务，HandlerThread内部又是一种使用Handler的Thread，这就意味着IntentService和Looper一样是顺序执行后台任务的
（HandlerThread：封装了Handler + ThreadHandlerThread适合在有需要一个工作线程（非UI线程）+任务的等待队列的形式，优点是不会有堵塞，减少了对性能的消耗，缺点是不能同时进行多个任务的处理，需要等待进行处理。处理效率低，可以当成一个轻量级的线程池来用）