Android IPC机制 开启多进程

    正常情况下，一个apk启动后只会运行在一个进程中，其进程名为AndroidManifest.xml文件中指定的应用包名，所有的基本组件都会在这个进程中运行。但是如果需要将某些组件（如Service、Activity等）运行在单独的进程中，就需要用到android:process属性了。我们可以为android的基础组件指定process属性来指定它们运行在指定进程中。

        对process属性的设置有两种形式：

        第一种形式如 android:process=":remote"，以冒号开头，冒号后面的字符串原则上是可以随意指定的。如果我们的包名为“com.example.processtest”，则实际的进程名为“com.example.processtest:remote”。这种设置形式表示该进程为当前应用的私有进程，其他应用的组件不可以和它跑在同一个进程中。

        第二种情况如 android:process="com.example.processtest.remote"，以小写字母开头，表示运行在一个以这个名字命名的全局进程中，其他应用通过设置相同的ShareUID可以和它跑在同一个进程。

        下面通过一个例子来进行一下验证。我们定义两个类：ProcessTestActivity和ProcessTestService，然后在AndroidManifest.xml文件中增加这两个类，并为我们的Service指定一个process属性，代码如下：

[html]  view plain  copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
3.     package="com.example.processtest"  
4.     android:versionCode="1"  
5.     android:versionName="1.0" >  
6.   
7.     <uses-sdk  
8.         android:minSdkVersion="8"  
9.         android:targetSdkVersion="19" />  
10.   
11.     <application  
12.         android:name="com.example.processtest.MyApplication"  
13.         android:icon="@drawable/ic_launcher"  
14.         android:label="@string/app_name">  
15.         <activity  
16.             android:name=".ProcessTestActivity"  
17.             android:label="@string/app_name" >  
18.             <intent-filter>  
19.                 <action android:name="android.intent.action.MAIN" />  
20.   
21.                 <category android:name="android.intent.category.LAUNCHER" />  
22.             </intent-filter>  
23.         </activity>  
24.           
25.         <service  
26.             android:name=".ProcessTestService"  
27.             android:process=":remote">  
28.         </service>  
29.     </application>  
30.   
31. </manifest>  

运行代码，通过DDMS进行观察，

       我们可以看到两个进程，名字分别是“com.example.processtest”和“com.example.processtest:remote”，进程ID分别为2722和2739。

       我们已经开启了应用内多进程，那么，开启多进程是不是只是我们看到的这么简单呢？其实这里面会有一些陷阱，稍微不注意就会陷入其中。开启多线程后，我们需要面临这样两个问题：

1）Application的多次重建。

2）静态成员的失效。

       我们先通过一个简单的例子来看一下第一种情况。

       Manifest文件如上面提到的，定义了两个类：ProcessTestActivity和ProcessTestService,我们只是在Activity的onCreate方法中直接启动了该Service，同时，我们自定义了自己的Application类。代码如下：

[html]  view plain  copy

1. public class MyApplication extends Application {  
2.     public static final String TAG = "viclee";  
3.     @Override  
4.     public void onCreate() {  
5.         super.onCreate();  
6.         int pid = android.os.Process.myPid();  
7.         Log.d(TAG, "MyApplication onCreate");  
8.         Log.d(TAG, "MyApplication pid is " + pid);  
9.     }  
10. }  

[html]  view plain  copy

1. public class ProcessTestActivity extends Activity {  
2.     public final static String TAG = "viclee";  
3.   
4.     @Override  
5.     protected void onCreate(Bundle savedInstanceState) {  
6.         super.onCreate(savedInstanceState);  
7.         setContentView(R.layout.activity_process_test);  
8.   
9.         Log.i(TAG, "ProcessTestActivity onCreate");  
10.         this.startService(new Intent(this, ProcessTestService.class));  
11.     }  
12. }  

[html]  view plain  copy

1. public class ProcessTestService extends Service {  
2.     public static final String TAG = "viclee";  
3.   
4.     @Override  
5.     public void onCreate() {  
6.         Log.i(TAG, "ProcessTestService onCreate");  
7.     }  
8.   
9.     @Override  
10.     public IBinder onBind(Intent arg0) {  
11.         return null;  
12.     }  
13.   
14. }  

       执行上面这段代码，查看打印信息：

       我们发现MyApplication的onCreate方法调用了两次，分别是在启动ProcessTestActivity和ProcessTestService的时候，而且我们发现打印出来的pid也不相同。由于通常会在Application的onCreate方法中做一些全局的初始化操作，它被初始化多次是完全没有必要的。出现这种情况，是由于即使是通过指定process属性启动新进程的情况下，系统也会新建一个独立的虚拟机，自然需要重新初始化一遍Application。那么怎么来解决这个问题呢？

       我们可以通过在自定义的Application中通过进程名来区分当前是哪个进程，然后单独进行相应的逻辑处理。

[html]  view plain  copy

1. public class MyApplication extends Application {  
2.     public static final String TAG = "viclee";  
3.   
4.     @Override  
5.     public void onCreate() {  
6.         super.onCreate();  
7.         int pid = android.os.Process.myPid();  
8.         Log.d(TAG, "MyApplication onCreate");  
9.         Log.d(TAG, "MyApplication pid is " + pid);  
10.   
11.         ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);  
12.         List<ActivityManager.RunningAppProcessInfo> runningApps = am.getRunningAppProcesses();  
13.         if (runningApps != null && !runningApps.isEmpty()) {  
14.             for (ActivityManager.RunningAppProcessInfo procInfo : runningApps) {  
15.                 if (procInfo.pid == pid) {  
16.                      if (procInfo.processName.equals("com.example.processtest")) {  
17.                          Log.d(TAG, "process name is " + procInfo.processName);  
18.                      } else if (procInfo.processName.equals("com.example.processtest:remote")) {  
19.                          Log.d(TAG, "process name is " + procInfo.processName);  
20.                      }  
21.                 }  
22.             }  
23.         }  
24.     }  
25. }  

       运行之后，查看Log信息，

       图中可以看出，不同的进程执行了不同的代码逻辑，可以通过这种方式来区分不同的进程需要完成的初始化工作。

       下面我们来看第二个问题，将之前定义的Activity和Service的代码进行简单的修改，代码如下：

[html]  view plain  copy

1. public class ProcessTestActivity extends Activity {  
2.     public final static String TAG = "viclee";  
3.     public static boolean processFlag = false;  
4.   
5.     @Override  
6.     protected void onCreate(Bundle savedInstanceState) {  
7.         super.onCreate(savedInstanceState);  
8.         setContentView(R.layout.activity_process_test);  
9.   
10.         processFlag = true;  
11.         Log.i(TAG, "ProcessTestActivity onCreate");  
12.         this.startService(new Intent(this, ProcessTestService.class));  
13.     }  
14. }  

[html]  view plain  copy

1. public class ProcessTestService extends Service {  
2.     public static final String TAG = "viclee";  
3.   
4.     @Override  
5.     public void onCreate() {  
6.         Log.i(TAG, "ProcessTestService onCreate");  
7.         Log.i(TAG, "ProcessTestActivity.processFlag is " + ProcessTestActivity.processFlag);  
8.     }  
9.   
10.     @Override  
11.     public IBinder onBind(Intent arg0) {  
12.         return null;  
13.     }  
14.   
15. }  

       重新执行代码，打印Log

       从上面的代码和执行结果看，我们在Activity中定义了一个标志processFlag并在onCreate中修改了它的值为true，然后启动Service，但是在Service中读到这个值却为false。按照正常的逻辑，静态变量是可以在应用的所有地方共享的，但是设置了process属性后，产生了两个隔离的内存空间，一个内存空间里值的修改并不会影响到另外一个内存空间。

       从上面的例子中我们可以看到，android实现应用内多进程并不是简单的设置属性process就可以了，而是会产生很多特殊的问题。像前面提到的，android启动多继承模式后，不仅静态变量会失效，而且类似的如同步锁机制、单例模式也会存在同样的问题。这就需要我们在使用的时候多加注意。而且设置多进程之后，各个进程间就无法直接相互访问数据，只能通过AIDL等进程间通信方式来交换数据。

转自http://blog.youkuaiyun.com/goodlixueyong/article/details/49853079

例子源代码下载