android 进程间 回调函数,android多进程

什么是进程

进程是一个具有独立功能的程序关于某个数据集合的一次运行活动。

进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时，它才能成为一个活动的实体，我们称其为进程。

通常在一个进程中可以包含若干个线程，它们可以利用进程所拥有的资源。

进程与线程的区别

进程是系统进行资源分配和调度的一个独立单位

线程是进程的一个实体, 是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源。它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序 健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

进程的级别

前台进程

前台进程是用户当前正在使用的进程。他们是最后一个被结束的。

属于前台进程的几种情况：

这个进程运行着一个正在和用户交互的Activity(这个Activity的onResume()方法被调用)。

这个进程里有绑定到当前正在和用户交互的Activity的service。

这个进程里有一个service对象，这个service对象正在执行一个它的生命周期的回调函数(onCreate(), onStart(), onDestroy())

这个进程里有一个正在调用onReceive()方法的BroadCastReiver对象。

可见进程

属于可见进程的情况：

进程中含有一个不位于前台的Activity，但是仍然对用户是可见的，即处于onPause阶段。

进程里有一个绑定到一个可见的Activity的Service。

服务进程

运行着一个通过startService() 方法启动的service。service所在的进程虽然对用户不是直接可见的，但是他们执行了用户非常关注的任务(比如播放mp3，从网络下载数据)。只要前台进程和可见进程有足够的内存，系统不会回收他们。

后台进程

运行着一个对用户不可见的activity(调用过 onStop() 方法)

空进程

没有任何程序在运行的进程。运行这些进程的唯一原因是作为一个缓存，缩短下次程序需要重新使用的启动时间。系统经常中止这些进程，这样可以调节程序缓存和系统缓存的平衡。

多进程使用

1.使用多进程的好处？

分担主进程的内存压力。Android系统对单个进程可使用的内存是有限制的，使用多进程，可以扩大单个App可使用的内存峰值，从而优化程序性能。

进程间互相隔离，更安全。

2.使用多进程的缺点？

多占了系统的内存空间，很容易沾满而导致卡顿，同时也消耗用户的电量。

在Android中，如果有新进程创建，由于进程本身需要一个Application，所以如果将应用中某个service声明为单独的进程时，当走到startService时，发现service是新进程，所以会新建一个进程放service，但service又需要一个Application，所以Application会再次执行一遍onCreate()。

优化：只在主应用进程初始化时，才执行全局初始化代码(参考Raymond_qi_kang

//以下是判断只有主进程初始化时，才进行 “全局初始化”

public class ApplicationTest extends Application {

@Override

public void onCreate() {

super.onCreate();

ActivityManager activityManager = (ActivityManager) getApplicationContext().getSystemService(Context.ACTIVITY_SERVICE);

//获得进程列表

List processList = activityManager.getRunningAppProcesses();

//获得当前pid

int pid = android.os.Process.myPid();

Log.i(MessengerService.TAG, "PID：" +pid);

//判断当前pid属于哪个进程

for (ActivityManager.RunningAppProcessInfo process : processList) {

if (pid == process.pid){

//找到了所属进程，判断进程名是否为 主进程名(默认为包名)

Log.i(MessengerService.TAG, "进程名：" + process.processName);

if (process.processName.equals(getPackageName())) {

Log.i(MessengerService.TAG, "主进程：全局初始化，只执行一次");

}

}

}

}

}

不同进程之间内存不能共享，最大的弊端是他们之间通信麻烦，不能将公用数据放在Application中，堆栈信息、文件操作也是独立的，如果他们之间传递的数据不大并且是可序列化的，可以考虑通过Bundle传递， 如果数据量较大，则需要通过AIDL或者文件操作来实现。

3.如何添加新的进程？

在Manifest中对四大组件(Activity，Service，Broadcast Receiver，ContentProvider)添加process属性.

多进程间通信(IPC)

多进程通信主要使用两种方法：

1.Messenger

2.AIDL(Android Interface Definition Language)

何时使用Messenger？何时使用AIDL？

1.Messenger: 多进程 +单线程

2.AIDL: 多进程 + 多线程

使用Messenger进行通信

使用Messenger的步骤:

Service需要实现一个Hanlder，用以处理从客户端收到的消息

用该Handler创建一个Messenger对象，Messenger对象内部会引用该Handler对象

用创建好的Messenger对象获得一个IBinder实例，并且将该IBinder通过Service的onBind方法返回给各个客户端

建立一个应用ServiceApp, 其中只有一个MyService类，没有其他Activity，也就是说ServiceApp没有任何UI界面。ServiceApp的manifest.xml文件如下所示:

package="com.ispring2.serviceapp" >

android:allowBackup="true"

android:icon="@drawable/ic_launcher"

android:label="ServiceApp">

android:name=".MyService"

android:enabled="true"

android:exported="true" >

// 声明为可被其他App调用的

ServiceApp中MyService的代码如下所示:

public class MyService extends Service {

private static final int RECEIVE_MESSAGE_CODE = 0x0001;

private static final int SEND_MESSAGE_CODE = 0x0002;

//clientMessenger表示的是客户端的Messenger，可以通过来自于客户端的Message的replyTo属性获得，

//其内部指向了客户端的ClientHandler实例，可以用clientMessenger向客户端发送消息

private Messenger clientMessenger = null;

//serviceMessenger是Service自身的Messenger，其内部指向了ServiceHandler的实例

//客户端可以通过IBinder构建Service端的Messenger，从而向Service发送消息，

//并由ServiceHandler接收并处理来自于客户端的消息

//用实现的Handler创建一个Messenger对象，Messenger对象内部会引用该Handler对象

private Messenger serviceMessenger = new Messenger(new ServiceHandler());

//Service需要实现一个Hanlder，用以处理从客户端收到的消息

//MyService用ServiceHandler接收并处理来自于客户端的消息

private class ServiceHandler extends Handler {

@Override

public void handleMessage(Message msg) {

Log.i("DemoLog", "ServiceHandler -> handleMessage");

if(msg.what == RECEIVE_MESSAGE_CODE){

Bundle data = msg.getData();

if(data != null){

String str = data.getString("msg");

Log.i("DemoLog", "MyService收到客户端如下信息: " + str);

}

//通过Message的replyTo获取到客户端自身的Messenger，

//Service可以通过它向客户端发送消息

clientMessenger = msg.replyTo;

if(clientMessenger != null){

Log.i("DemoLog", "MyService向客户端回信");

Message msgToClient = Message.obtain();

msgToClient.what = SEND_MESSAGE_CODE;

//可以通过Bundle发送跨进程的信息

Bundle bundle = new Bundle();

bundle.putString("msg", "你好，客户端，我是MyService");

msgToClient.setData(bundle);

try{

clientMessenger.send(msgToClient);

}catch (RemoteException e){

e.printStackTrace();

Log.e("DemoLog", "MyService向客户端发送信息失败: " + e.getMessage());

}

}

}

}

}

@Override

public void onCreate() {

Log.i("DemoLog", "MyService -> onCreate");

super.onCreate();

}

@Override

public IBinder onBind(Intent intent) {

Log.i("DemoLog", "MyServivce -> onBind");

//获取Service自身Messenger所对应的IBinder，并将其发送共享给所有客户端

return serviceMessenger.getBinder();

}

@Override

public void onDestroy() {

Log.i("DemoLog", "MyService -> onDestroy");

clientMessenger = null;

super.onDestroy();

}

}

客户端通过收到的IBinder对象实例化一个Messenger对象，该Messenger内部指向指向Service中的Handler。客户端通过该Messenger对象就可以向Service中的Hanlder发送消息。

Service中的Hanlder收到消息后，在Handler中的handleMessage方法中处理消息。

通过上面的第4步与第5步，就完成了客户端向Service发送消息并且Service接收到消息的单向通信过程，即客户端 -> Service。

如果要实现Service向客户端回消息的通信过程，即Service -> 客户端，那么前提是在客户端中也需要像Service一样内部维护有一个指向Handler的Messenger。当在第四步中客户端向Service发送信息时，将Message的replyTo属性设置为客户端自己的Messenger。这样在第5步Service在Handler的handleMessage中处理收到的消息时，可以通过Message的Messenger再向客户端发送Message，这样客户端内维护的Handler对象就会收到来自于Service的Message，从而完成Service向客户端发送消息且客户端接收到消息的通信过程。

新建一个ClientApp, 该App是客户端，用于调用服务

public class MainActivity extends Activity {

private static final int SEND_MESSAGE_CODE = 0x0001;

private static final int RECEIVE_MESSAGE_CODE = 0x0002;

private boolean isBound = false;

//用于启动MyService的Intent对应的action

private final String SERVICE_ACTION = "com.ispring2.action.MYSERVICE";

//serviceMessenger表示的是Service端的Messenger，其内部指向了MyService的ServiceHandler实例

//可以用serviceMessenger向MyService发送消息

private Messenger serviceMessenger = null;

//clientMessenger是客户端自身的Messenger，内部指向了ClientHandler的实例

//MyService可以通过Message的replyTo得到clientMessenger，从而MyService可以向客户端发送消息，

//并由ClientHandler接收并处理来自于Service的消息

private Messenger clientMessenger = new Messenger(new ClientHandler());

//客户端用ClientHandler接收并处理来自于Service的消息

private class ClientHandler extends Handler {

@Override

public void handleMessage(Message msg) {

Log.i("DemoLog", "ClientHandler -> handleMessage");

if(msg.what == RECEIVE_MESSAGE_CODE){

Bundle data = msg.getData();

if(data != null){

String str = data.getString("msg");

Log.i("DemoLog", "客户端收到Service的消息: " + str);

}

}

}

}

private ServiceConnection conn = new ServiceConnection() {

@Override

public void onServiceConnected(ComponentName name, IBinder binder) {

//客户端与Service建立连接

Log.i("DemoLog", "客户端 onServiceConnected");

//我们可以通过从Service的onBind方法中返回的IBinder初始化一个指向Service端的Messenger

serviceMessenger = new Messenger(binder);

isBound = true;

Message msg = Message.obtain();

msg.what = SEND_MESSAGE_CODE;

//此处跨进程Message通信不能将msg.obj设置为non-Parcelable的对象，应该使用Bundle

//msg.obj = "你好，MyService，我是客户端";

Bundle data = new Bundle();

data.putString("msg", "你好，MyService，我是客户端");

msg.setData(data);

//需要将Message的replyTo设置为客户端的clientMessenger，

//以便Service可以通过它向客户端发送消息

msg.replyTo = clientMessenger;

try {

Log.i("DemoLog", "客户端向service发送信息");

serviceMessenger.send(msg);

} catch (RemoteException e) {

e.printStackTrace();

Log.i("DemoLog", "客户端向service发送消息失败: " + e.getMessage());

}

}

@Override

public void onServiceDisconnected(ComponentName name) {

//客户端与Service失去连接

serviceMessenger = null;

isBound = false;

Log.i("DemoLog", "客户端 onServiceDisconnected");

}

};

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

}

}

使用AIDL

AIDL实现步骤：

在目录main先新建aidl文件夹，在文件夹下新建一个aidl文件

新建好aidl文件后点击build或run，在debug中生成最终的aidl文件

interface IMyAidlInterface {

/**

* Demonstrates some basic types that you can use as parameters

* and return values in AIDL.

*/

void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,

double aDouble, String aString);

/* 添加自定义接口方法*/

void printLog(String msg);

}

新建service，并在其中实现aidl接口中的方法 ， 通过Binder把接口实例传出去

public class AidlService extends Service {

IMyAidlInterface.Stub mStub = new IMyAidlInterface.Stub() {

@Override

public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

}

@Override

public void printLog(String msg) throws RemoteException {

Log.i("printLog", "the messager is " + msg);

}

};

@Nullable

@Override

public IBinder onBind(Intent intent) {

return mStub;

}

}

绑定Service，通过binder获得接口实例引用

private ServiceConnection mServiceConnection = new ServiceConnection() {

@Override

public void onServiceConnected(ComponentName name, IBinder service) {

//获得Service实现的Aidl接口对象

mAidlInterface = IMyAidlInterface.Stub.asInterface(service);

try {

//调用接口，执行跨进程方法

mAidlInterface.printLog("使用aidl");

} catch (RemoteException e) {

e.printStackTrace();

}

}

}