Multi-process communication methods and a series of problems

[[434195]]

This article is reprinted from the WeChat public account "Android Development Programming", the author is Android Development Programming. Please contact the Android Development Programming public account for reprinting this article.

Preface

Today, let's talk about: multi-process communication methods and the problems they bring, so that problems can be dealt with in a timely manner when encountered in the project;

1. Detailed explanation of multiple processes in Android

1. Definition

• Android's multi-process communication, or IPC, refers to data exchange between two processes;
• A process generally refers to an execution unit, which in PCs and mobile devices refers to a program or application;
• In the simplest case, there is only one process in an Android application, which contains one thread, namely the main thread, also called the UI thread, and the UI can only be updated and operated in this thread;
• Under normal circumstances, multi-process is not needed, but when the application needs more memory or some special modules or special requirements need to run under multi-process conditions;

2. Start multiple processes

There is only one way to enable multiple processes in Android, which is to specify the android:process attribute when registering Service, Activity, Receiver, and ContentProvider in AndroidManifest.xml, for example:

 <service
    android: name = ".MyService"  
    android:process= ":remote" >
 </service>
 <activity
    android: name = ".MyActivity"  
    android:process= "com.test.remote2" >
 </activity>

The android:process attribute values ​​we specify for MyService and MyActivity are different. The differences are as follows:

• :remote: Starting with : is an abbreviation. The system will append the current package name before the current process name. The full process name is: com.test:remote. At the same time, the process starting with : belongs to the private process of the current application. Components of other applications cannot run in the same process with it;
• com.test.remote2: This is the complete naming method, without the package name. If other applications have the same ShareUID and signature as this process, they can run in the same process to achieve data sharing;

3. Multi-process communication in Android

There are mainly the following multi-process communication methods, each of which has its own advantages and disadvantages. You can choose according to the usage scenario:

• AIDL: powerful, supports one-to-many real-time concurrent communication between processes, and can implement RPC (remote procedure call);
• Messenger: supports one-to-many serial real-time communication, a simplified version of AIDL;
• Bundle: The process communication method of the four major components can only transmit data types supported by Bundle;
• ContentProvider: Powerful data source access support, mainly supporting CRUD operations and one-to-many inter-process data sharing, such as our application accessing the system's address book data;
• BroadcastReceiver: Broadcast, but only one-way communication, the receiver can only receive messages passively;
• File sharing: Share simple data in non-high-concurrency situations;
• Socket: transmits data over the network;

2. Problems caused by multiple processes

1. Static variables are invalid

Create a static variable TEST_STATIC in an Activity and increment it in the onStartOtherRemoteActivity method in RemoteActivity1. Then start RemoteActivity2 and print the value of TEST_STATIC in 2.

 public   static   int TEST_STATIC = 21;
 public void onStartOtherRemoteActivity( View   view ) {
 TEST_STATIC++;
    Log.e(TAG, "onStartOtherRemoteActivity: " + TEST_STATIC);
    startActivity(new Intent(this, RemoteActivity2.class));
 }
 result:
 // RemoteActivity1 log
 E/RemoteActivity1: onStartOtherRemoteActivity: 22
 // RemoteActivity2 log
 E/RemoteActivity2: onCreate: 21

The different values ​​indicate that static variables are invalid in multiple processes. Similarly, the problem caused by static variables is the invalidation of the singleton mode.

The reason is that when there are multiple processes, Android allocates a new virtual machine for other processes, resulting in different virtual machines having different memory addresses in memory. When a variable is accessed in a new process, what is accessed is actually the copy of this class in the new virtual machine, which is equivalent to having a RemoteActivity1 class in :remote and .remote respectively, and the TEST_STATIC in the copy accessed by .remote is not incremented, so the initial value of 21 will still be printed, while the value in :remote is incremented to 22;

The same explanation applies to the singleton pattern. When a singleton class is accessed in another process, it is not actually initialized in this process, so it becomes invalid.

2. Thread synchronization mechanism fails

It is essentially similar to a static variable. In one process, the object of the copy is locked, but in the other copy, the memory is different, so it is definitely invalid.

3. SharedPreferences reliability decreases

SharedPreferences does not support two processes performing write operations at the same time, otherwise it will cause a certain probability of data loss;

The underlying layer of SharedPreferences is implemented by reading and writing XML files. Concurrent writing is likely to cause problems, and concurrent reading and writing cannot guarantee that there will be no problems.

4. Application will be created multiple times

When a component runs in a new process, the system allocates a new virtual machine to the new process, which is equivalent to restarting the application again. The Application as the basis of the application will definitely be recreated;

Create a new Application class, inherit from Application, and output the PID of the current process in the onCreate method:

 public class LApplication extends Application {
    private static final String TAG = "LApplication" ;
 @Override
 public void onCreate() {
 super.onCreate();
        Log.e(TAG, "onCreate: " + android.os.Process.myPid());
 }
 }

When the processes are started one by one, the output is as follows:

 // Main
 E/LApplication: onCreate: 16031
 // RemoteActivity1
 E/LApplication: onCreate: 16127
 // RemoteActivity2
 E/LApplication: onCreate: 16202

The problem with creating an Application multiple times is that sometimes you need to initialize some dependencies in the Application, but multiple processes will be initialized repeatedly as the Application is created. You can set some conditions in the Application to skip the repeated initialization part;

 // Get the process name based on pid
 private String getAppName( int pid) {
    String processName = null ;
    ActivityManager am = (ActivityManager) this.getSystemService(ACTIVITY_SERVICE);
    List<ActivityManager.RunningAppProcessInfo> list = am.getRunningAppProcesses();
 for (ActivityManager.RunningAppProcessInfo info : list) {
 try {
            if (info.pid == pid) {
                processName = info.processName;
 return processName;
 }
        } catch (Exception e) {
            e.printStackTrace();
 return   null ;
 }
 }
 return   null ;
 }

Get the process name through PID and compare it with the package name. Only if it matches the package name, do some initialization work.

Summarize

I didn’t talk about multi-process implementation today, but I will explain it later;

Multi-process is not difficult, the difficulty lies in overcoming difficulties and defeating yourself;