什么是进程
进程是一个具有独立功能的程序关于某个数据集合的一次运行活动。
进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时，它才能成为一个活动的实体，我们称其为进程。
通常在一个进程中可以包含若干个线程，它们可以利用进程所拥有的资源。
进程与线程的区别
- 进程是系统进行资源分配和调度的一个独立单位
- 线程是进程的一个实体, 是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<ActivityManager.RunningAppProcessInfo> 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文件如下所示:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.ispring2.serviceapp" >
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="ServiceApp">
<service
android:name=".MyService"
android:enabled="true"
android:exported="true" >
// 声明为可被其他App调用的
<intent-filter>
<action android:name="com.ispring2.action.MYSERVICE" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</service>
</application>
</manifest>
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();
}
}
}
