android多进程

什么是进程

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

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

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

进程与线程的区别

• 进程是系统进行资源分配和调度的一个独立单位
• 线程是进程的一个实体, 是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源。它可与同属一个进程的其他的线程共享进程所拥有的全部资源。
• 一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。

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

进程的级别

1. 前台进程
   前台进程是用户当前正在使用的进程。他们是最后一个被结束的。
   属于前台进程的几种情况：

• 这个进程运行着一个正在和用户交互的Activity（这个Activity的onResume()方法被调用）。
• 这个进程里有绑定到当前正在和用户交互的Activity的service。
• 这个进程里有一个service对象，这个service对象正在执行一个它的生命周期的回调函数(onCreate(), onStart(), onDestroy())
• 这个进程里有一个正在调用onReceive()方法的BroadCastReiver对象。

2. 可见进程
   属于可见进程的情况：

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

3. 服务进程
   运行着一个通过startService() 方法启动的service。service所在的进程虽然对用户不是直接可见的，但是他们执行了用户非常关注的任务（比如播放mp3，从网络下载数据）。只要前台进程和可见进程有足够的内存，系统不会回收他们。
4. 后台进程
   运行着一个对用户不可见的activity（调用过 onStop() 方法)
5. 空进程
   没有任何程序在运行的进程。运行这些进程的唯一原因是作为一个缓存，缩短下次程序需要重新使用的启动时间。系统经常中止这些进程，这样可以调节程序缓存和系统缓存的平衡。

多进程使用

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的步骤:

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

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

3. 用创建好的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();
    }
}

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

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

6. 通过上面的第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实现步骤：

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

2. 新建好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);
}

3. 新建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;
    }
}

4. 绑定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();
            }
        }
}