android线程间的通信
㈠ Android 进程间通信的几种实现方式
Android 进程间通信的几种实现方式
主要有4种方式：
这4种方式正好对应于android系统中4种应用程序组件：Activity、Content Provider、Broadcast和Service。
主要实现原理：
由于应用程序之间不能共享内存。为了在不同应用程序之间交互数据（跨进程通讯），AndroidSDK中提供了4种用于跨进程通讯的方式进行交互数据，实现进程间通信主要是使用sdk中提供的4组组件根据实际开发情况进行实现数据交互。
详细实现方式：
Acitivity实现方式
Activity的跨进程访问与进程内访问略有不同。虽然它们都需要Intent对象，但跨进程访问并不需要指定Context对象和Activity的 Class对象，而需要指定的是要访问的Activity所对应的Action（一个字符串）。有些Activity还需要指定一个Uri（通过 Intent构造方法的第2个参数指定）。 在android系统中有很多应用程序提供了可以跨进程访问的Activity，例如，下面的代码可以直接调用拨打电话的Activity。
java">IntentcallIntent=newIntent(Intent.ACTION_CALL,Uri.parse("tel:12345678");
startActivity(callIntent);Content Provider实现方式
Android应用程序可以使用文件或SqlLite数据库来存储数据。Content Provider提供了一种在多个应用程序之间数据共享的方式（跨进程共享数据）
应用程序可以利用Content Provider完成下面的工作
1. 查询数据
2. 修改数据
3. 添加数据
4. 删除数据
Broadcast 广播实现方式
广播是一种被动跨进程通讯的方式。当某个程序向系统发送广播时，其他的应用程序只能被动地接收广播数据。这就象电台进行广播一样，听众只能被动地收听，而不能主动与电台进行沟通。在应用程序中发送广播比较简单。只需要调用sendBroadcast方法即可。该方法需要一个Intent对象。通过Intent对象可以发送需要广播的数据。
Service实现方式
常用的使用方式之一：利用AIDL Service实现跨进程通信
这是我个人比较推崇的方式，因为它相比Broadcast而言，虽然实现上稍微麻烦了一点，但是它的优势就是不会像广播那样在手机中的广播较多时会有明显的时延，甚至有广播发送不成功的情况出现。
注意普通的Service并不能实现跨进程操作，实际上普通的Service和它所在的应用处于同一个进程中，而且它也不会专门开一条新的线程，因此如果在普通的Service中实现在耗时的任务，需要新开线程。
要实现跨进程通信，需要借助AIDL(Android Interface Definition Language)。Android中的跨进程服务其实是采用C/S的架构，因而AIDL的目的就是实现通信接口。
总结
跨进程通讯这个方面service方式的通讯远远复杂于其他几种通讯方式，实际开发中Activity、Content Provider、Broadcast和Service。4种经常用到，学习过程中要对没种实现方式有一定的了解。
㈡ 安卓多线程间通信和多进程之间通信有什么不同
1.安卓线程间通信的方式有以下几种1）共享变量（内存）
2）管道
3）handle机制
runOnUiThread(Runnable)
view.post(Runnable)
android 进程内的消息驱动机制---Handler,MessageQueue,Runnable,Looper
Looper和Message的处理机制:首先在主线程中创建了一个handler对象,目的是为了处理从子线程发送过来的消息,然后当子线程有发送消息的需求时会使用Message对象,消息首先会被存储在Message queue消息队列中,主线程还有一个Looper消息轮询器,会循环遍历消息队列中的消息,当发现消息的时候会发送消息给handler处理(更新ui等操作),handler调用handleMessage处理完后将Message置为null以便回收.
2进程间的通信
进程间的通信：
bind机制（IPC->AIDL)
linux级共享内存
boradcast
Activity之间可以通过intent来传递数据
3.安卓结束进程几种方式
1)使用ActivityManager中的restartPackage(String packname)方法,这里清单文件里面要配置权限
2)android.os.process.killProcess(int pid)只能终止本程序的进程
3)System.exit()
4)在android2.2版本之后则不能再使用restartPackage()方法，而应该使用killBackgroundProcesses()方法,同时应该配置权限
5)利用反射调用forceStopPackage来结束- Method forceStopPackage = am.getClass().getDeclaredMethod("forceStopPackage", String.class);
- forceStopPackage.setAccessible(true);
- forceStopPackage.invoke(am, yourpkgname);
6)使用Linux指令kill -9
㈢ Android——消息分发机制
什么是 Handler 机制 ？
Handler 机制是 Android 中用于 线程间通信 的一套通信机制。
为什么是 Handler ？Handler 机制为什么被那么多次的提及 ？
从Android4.0开始，Android 中网络请求强制不允许在主线程中操作，而更新UI的操作则不允许在子线程中执行。当在子线程中执行网络请求，拿到服务器返回的数据之后，要更新UI。由于系统的要求，势必会产生一种矛盾：数据在子线程，更新UI要在主线程。此时我们必须要把数据返回到主线程中才行，Handler机制应运而生。
Android 中针对耗时的操作，放在主线程操作，轻者会造成 UI 卡顿，重则会直接无响应，造成 Force Close。同时在 Android 3.0 以后，禁止在主线程进行网络请求。
针对耗时或者网络操作，那就不能在主线程进行直接操作了，需要放在子线程或者是工作线程中进行操作，操作完成以后，再更新主线程即 UI 线程。这里就涉及到一个问题了，在子线程执行完成以后，怎么能更新到主线程即 UI 线程呢，针对以上问题，就需要用到 Android 的消息机制了，即： Handler, Message, MessageQueue, Looper 全家桶
Handler机制中最重要的四个对象
Handler的构造方法:
Looper :
Handler的使用：
MessageQueue：
Looper.loop()
Handler.dispatchMessage()
handler导致activity内存泄露的原因：
handler发送的消息在当前handler的消息队列中，如果此时activity finish掉了，那么消息队列的消息依旧会由handler进行处理，若此时handler声明为内部类（非静态内部类），我们知道内部类天然持有外部类的实例引用，这样在GC垃圾回收机制进行回收时发现这个Activity居然还有其他引用存在，因而就不会去回收这个Activity，进而导致activity泄露。
假如在子线程执行了耗时操作，这时用户操作进入了其他的 acitvity， 那么 MainActivity 就会被内存回收的，但是这个时候发现 Handler 还在引用着 MainActivity，内存无法及时回收，造成内存泄漏。
Handler 防止内存泄漏常见方法：
为什么通过 Handler 可以把子线程的结果通知或者携带给 UI 线程 ？
这里的 Handler 指的是主线程的 Handler ,同时与 Handler 配套的 Looper ， MessageQueue 是在 UI 线程初始化的，所以在子线程中调用 Handler 发送消息可以更新 UI 线程。
Looper 在 UI 线程源码, 在 ActivityThread 类：
㈣ Android消息机制和原理
Android消息机制及其原理
Handle的原理
andriod提供了Handler和Looper来满足线程间的通信。Handler先进先出原则。Looper类用来管理特定线程内对象之间的消息交换(MessageExchange)。
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是多对一
Handler
在主线程构造一个Handler，与Looper沟通，以便push新消息到MessageQueue里;
接收Looper从MessageQueue取出Handler所送来的消息。然后在其他线程调用sendMessage(),此时主线程的MessageQueue中会插入一条message，然后被Looper使用.
Thread
UIthread 通常就是main thread，而Android启动程序时会替它建立一个MessageQueue,系统的主线程在ActivityThread的main()为入口开启主线程，其中定义了一系列消息类型，包含四大组件的启动停止。
消息队列分发算法源码
每个message之间拉手，知道自己前面和后面的message
message通过时间戳来排序，小的在前
配合handle取出message，message时间到，就去除队列首个message，取出之后置为null，第二个message就排在第一，类推
//消息的存放
boolean enqueueMessage(Message msg, long when) {
synchronized (this) {
msg.when = when;
Message p = mMessages; //注解1
if (p == null || when == 0 || when < p.when){
msg.next = p;
mMessages = msg; //注解2
} else {
Message prev;
for (;;) { //注解3
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
}
msg.next = p;
prev.next = msg;
}
}
return true;
}
㈤ android中什么时候会选择用广播来进行线程间的通信
android中什么时候会选择用广播来进行线程间的通信 Android 多线程 通信
线程中通信就不要用广播了吧 进程中通信可以用广播或者aidl
可是，这两天看到的项目都是这么做的；然后，自己分析了下，觉得一下的理由也是可以成立的；
1.正常情况下我们选择handler消息机制来进行单向的线程间的通信；（工作线程向主线程发送消息）
因为主线程有现成的handler，而工作线程没有现成的handler，这样的话，主线程将handler交给工作线程而让工作线程将工作的结果交给主线程；
相反，工作线程中没有现成的handler（事实上是没有消息队列，也就是handler没有绑定到工作线程），那么，如果开辟的话，代码角度上是挺麻烦的（相对应广播机制来说）；
2.广播机制本身就是双向的（工作线程向主线程发送广播，主线程向工作线程发送广播）；
//另外，对于像一个activity中通过fragment来进行界面的处理； 我们大多数情况下是采用广播的机制来实现fragment中adapter的数据的更新；这样做主要是考虑到工作线程的任务加载完成，而具体的对应刷新的activity可能还没有启动；
另外，基于接口隔离原则，如果用handler进行通信的话，则不能很好的满足这一原则；
你要是周期比较长 用广播好些吧
应该与周期关系不是很密切。最主要的原因是两条线成是双向通信。
Handler类似于P2P的通信。
广播则类似于一个server端，用来处理分发不同线程的请求，从控制器的角度来说用广播更好一点。
一般使用Handler的，多用于子线程处理事务，完成时告知主线程这一类的情况。
而类似楼主所说的多条线程之间需要频繁交互的话，广播是个很好的选择，并且结构清晰，只是不知道广播的性能与handler相比会怎么样。
㈥ Android的handler机制的原理
Android的handler机制的原理分为异步通信准备，消息发送，消息循环，消息处理。
1、异步通信准备
在主线程中创建处理器对象(Looper)、消息队列对象(Message Queue)和Handler对象。
2、消息入队
工作线程通过Handler发送消息(Message) 到消息队列(Message Queue)中。
3、消息循环
消息出队: Looper循环取出消息队列(Message Queue) 中的的消息(Message)。
消息分发: Looper将取出的消息 (Message) 发送给创建该消息的处理者(Handler)。
4、消息处理
处理者(Handler) 接收处理器(Looper) 发送过来的消息(Message)，根据消息(Message) 进行U操作。
handler的作用
handler是android线程之间的消息机制，主要的作用是将一个任务切换到指定的线程中去执行，（准确的说是切换到构成handler的looper所在的线程中去出处理）android系统中的一个例子就是主线程中的所有操作都是通过主线程中的handler去处理的。
Handler的运行需要底层的 messagequeue和 looper做支撑。
㈦ android线程间通信有哪些方式
进程：是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。
线程：是进程的一个实体,是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();
㈧ android开发中跨进程通信有几种方式
Android进程间通信的几种方式 定义多进程
第一：Android应用中使用多进程只有一个办法（用NDK的fork来做除外），就是在AndroidManifest.xml中声明组件时，用android:process属性来指定。
不知定process属性，则默认运行在主进程中，主进程名字为包名。
android:process = package:remote，将运行在package:remote进程中，属于全局进程，其他具有相同shareUID与签名的APP可以跑在这个进程中。
android:process = :remote ，将运行在默认包名:remote进程中，而且是APP的私有进程，不允许其他APP的组件来访问。
第二：多进程引发的问题
静态成员和单例失效：每个进程保持各自的静态成员和单例，相互独立。
线程同步机制失效：每个进程有自己的线程锁。
SharedPreferences可靠性下降：不支持并发写，会出现脏数据。
Application多次创建：不同进程跑在不同虚拟机，每个虚拟机启动会创建自己的Application，自定义Application时生命周期会混乱。
综上，不同进程拥有各自独立的虚拟机，Application，内存空间，由此引发一系列问题。
第三： 进程间通信
Bundle/Intent传递数据：
可传递基本类型，String，实现了Serializable或Parcellable接口的数据结构。Serializable是Java的序列化方法，Parcellable是Android的序列化方法，前者代码量少（仅一句），但I/O开销较大，一般用于输出到磁盘或网卡；后者实现代码多，效率高，一般用户内存间序列化和反序列化传输。
文件共享：
对同一个文件先后写读，从而实现传输，Linux机制下，可以对文件并发写，所以要注意同步。顺便一提，Windows下不支持并发读或写。
Messenger：
Messenger是基于AIDL实现的，服务端（被动方）提供一个Service来处理客户端（主动方）连接，维护一个Handler来创建Messenger，在onBind时返回Messenger的binder。
双方用Messenger来发送数据，用Handler来处理数据。Messenger处理数据依靠Handler，所以是串行的，也就是说，Handler接到多个message时，就要排队依次处理。
AIDL：
AIDL通过定义服务端暴露的接口，以提供给客户端来调用，AIDL使服务器可以并行处理，而Messenger封装了AIDL之后只能串行运行，所以Messenger一般用作消息传递。
通过编写aidl文件来设计想要暴露的接口，编译后会自动生成响应的java文件，服务器将接口的具体实现写在Stub中，用iBinder对象传递给客户端，客户端bindService的时候，用asInterface的形式将iBinder还原成接口，再调用其中的方法。
ContentProvider：
系统四大组件之一，底层也是Binder实现，主要用来为其他APP提供数据，可以说天生就是为进程通信而生的。自己实现一个ContentProvider需要实现6个方法，其中onCreate是主线程中回调的，其他方法是运行在Binder之中的。自定义的ContentProvider注册时要提供authorities属性，应用需要访问的时候将属性包装成Uri.parse("content://authorities")。还可以设置permission，readPermission，writePermission来设置权限。 ContentProvider有query，delete，insert等方法，看起来貌似是一个数据库管理类，但其实可以用文件，内存数据等等一切来充当数据源，query返回的是一个Cursor，可以自定义继承AbstractCursor的类来实现。
Socket：
学过计算机网络的对Socket不陌生，所以不需要详细讲述。只需要注意，Android不允许在主线程中请求网络，而且请求网络必须要注意声明相应的permission。然后，在服务器中定义ServerSocket来监听端口，客户端使用Socket来请求端口，连通后就可以进行通信。