Android multi-process communication - in-depth understanding

[[405775]]

1. What is multi-process?

Normally, in the Android system, after an app is started, it will only run in one process, whose process name is the package name of apk, and all components will run in this process;

However, if you need to run certain components (such as Service, Activity, etc.) in a separate process, you need to use the android:process attribute.

We can set the android:process attribute for the Android component to make it run in the specified process.

1. Advantages of multi-process:

①Use more memory

The Android system has a limit on the memory usage of each application process, and the larger the memory usage of a process, the more likely it is to be killed by the system. Running a component in a separate process can reduce the memory used by the main process, avoid OOM problems, and reduce the probability of being killed by the system.

②Realize multiple modules

For example, WeChat’s mini-programs (one main process and one mini-program process) and Alipay’s mini-programs;

When you start a mini program, the mini program process will be started, which will not occupy the memory of the main process, making the mini program process separate and much faster.

③The child process crashes, and the main process can continue to work

④The main process exits and the child process can continue to work

⑤Implementing the daemon process

Use C/C++ through JNI to call the fork() method to generate a child process. Generally, developers will use this method to create some daemon processes to achieve anti-killing and keep-alive effects.

2. Problems caused by multiple processes

①Static members and singleton mode are invalid

②Thread synchronization mechanism fails

③SharedPreferences reliability is reduced

④Application is created multiple times

⑤Multi-process interaction is troublesome

Causes:

In Android, the system allocates an independent virtual machine for each application or process. Different virtual machines naturally occupy different memory address spaces.

Therefore, objects of the same class will produce different copies, resulting in failure of shared data and inevitable failure to achieve thread synchronization.

2. Multi-process communication mode

There are mainly the following multi-process communication methods supported in Android. Each of them 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

Broadcasting is a passive cross-process communication method. When a program sends a broadcast to the system, other applications can only passively receive the broadcast data.

This is just like a radio station broadcasting. Listeners can only listen passively but cannot actively communicate with the radio station. It is relatively simple to send broadcasts in the application.

Just call the sendBroadcast method. This method requires an Intent object. The Intent object can be used to send the data to be broadcasted.

• File sharing: Sharing simple data in non-high-concurrency situations.
• Socket: Transmits data over the network.

This time we will introduce AIDL and Messenger, two commonly used interaction methods in daily APP development.

As shown

1. Multi-process AIDL communication

AIDL is the Android interface definition language, which is a description language used to define the communication interface between the server and the client. It can be used to define the programming interface of the inter-process communication (IPC) between the client and the server.

In Android, processes cannot share memory (user space), and communication between different processes is generally handled using AIDL.

Simple steps to use:

Create an AIDL file (with the extension .aidl);

Expose an interface to the client (by establishing a Service and returning an instance of the Stub class in the onBind() method);

The server implements the Java interface generated by the AIDL file (the system will automatically generate the corresponding Java interface);

The client connection is bound to the remote service.

①Create AIDL file

Create an AIDL file, declare the interface that the server wants to expose to the client, then create a Service to listen to the client's connection request and implement the interface in the AIDL file

Note that for the convenience of development, we generally put AIDL related files in the same package, so that when the client is another application, the entire package can be easily copied to the client project.

First, let's take a look at the data types supported by AIDL files:

• Basic Data Types
• String, CharSequence
• ArrayList, HashMap, and their internal elements also need to be supported by AIDL
• An object that implements the Parcelable interface
• AIDL type interface, not a normal interface

Book is a class that implements Parcelable. It only defines the name field. According to the regulations, if the AIDL file uses a custom Parcelable object, a Book.aidl file must also be provided.

 package com.json; 
 
 
 parcelable Book;

②ILibraryManager.aidl defines the interface that the server will expose to the client:

 package com.json; 
 
 import com.json.Book; 
 
 interface ILibraryManager{
 // Recent new book search
    List<Book> getNewBookList();
 // Book Donation
    void donateBook( in Book book);
 }

③The next step is the Java interface generated by the AIDL file. Before writing the service class, you must compile the project first so that the java class generated by AIDL can be used in the service class.

First, create an mBinder object through ILibraryManager.Stub(), implement the interface method defined in ILibraryManager.aidl, return the created mBinder in the onBind() method, and add data in the service onCreate().

Finally, register the service in AndroidManifest.xml:

 <service
    android: name = ".ManagerService"  
    android:process= ":remote" >
 </service> 

 public class ManagerService extends Service { 
 
    private static final String TAG = "ManagerService" ; 
 
 // CopyOnWriteArrayList supports concurrent reading and writing
    private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<>(); 
 
    private Binder mBinder = new ILibraryManager.Stub() { 
 
 @Override
 public List<Book> getNewBookList() throws RemoteException {
 return mBookList;
 } 
 
 @Override
 public void donateBook(Book book) throws RemoteException {
            mBookList.add (book);
 }
 }; 
 
 public LibraryManagerService() {
 } 
 
 @Override
 public IBinder onBind(Intent intent) {
 return mBinder;
 } 
 
 @Override
 public void onCreate() {
 super.onCreate();
        mBookList.add (new Book( "book0" ));
        mBookList.add (new Book( "book1" ));
 }
 }

④The client connects and binds the remote service

First implement the ServiceConnection interface, and convert the IBinder object into an ILibraryManager object in the onServiceConnected() method. Through this object, you can call the methods declared in ILibraryManager.aidl.

Next, bind the service:

 public class AIDLActivity extends AppCompatActivity {
    private static final String TAG = "AIDLActivity" ;
   ILibraryManager libraryManager= null ;
    private ServiceConnection mServiceConnection = new ServiceConnection() {
 @Override
 public void onServiceConnected(ComponentName name , IBinder service) {
             libraryManager = ILibraryManager.Stub.asInterface(service);
 try {
 //test1
                List<Book> books = libraryManager.getNewBookList();
                Log.e(TAG, "books:" + books.toString());
 //test2
                libraryManager.donateBook(new Book( "book" + books. size ()));
                List<Book> books2 = libraryManager.getNewBookList();
                Log.e(TAG, "books:" + books2.toString());
            } catch (RemoteException e) {
                e.printStackTrace();
 }
 } 
 
 @Override
 public void onServiceDisconnected(ComponentName name ) { 
 
 }
 }; 
 
 void bindAidlData(){
      if( null ==libraryManager){
 return ;
 }
 try {
 //test1
                List<Book> books = libraryManager.getNewBookList();
                Log.e(TAG, "books:" + books.toString());
 //test2
                libraryManager.donateBook(new Book( "book" + books. size ()));
                List<Book> books2 = libraryManager.getNewBookList();
                Log.e(TAG, "books:" + books2.toString());
            } catch (RemoteException e) {
                e.printStackTrace();
 }
 }
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_aidl);
 bindNewService();
 } 
 
    private void bindNewService() {
        Intent intent = new Intent(AIDLActivity.this, LibraryManagerService.class);
        bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
 } 
 
 @Override
    protected void onDestroy() {
        unbindService(mServiceConnection);
 super.onDestroy();
 }
 }

2. Notification function of aidl

First, create an IOnNewBookArrivedListener.aidl interface for the server to notify the client:

 package com.json; 
 
 
 import com.json.Book; 
 
 
 interface IOnNewBookArrivedListener {
    void onNewBookArrived( in Book book);
 }

The server must register before it can receive notifications, and it can also unregister, so we need to add two methods to the previous ILibraryManager.aidl:

 interface ILibraryManager{
 ......
 //Register notification
    void register(IOnNewBookArrivedListener listener);
 // Unregister
    void unregister(IOnNewBookArrivedListener listener);
 }

Modify ManagerService:

 public class ManagerService extends Service {
 ......
 ......
 ......
 // Class provided by the system specifically for saving and deleting cross-process listeners
    private RemoteCallbackList<IOnNewBookArrivedListener> mListenerList = new RemoteCallbackList<>();
 // AtomicBoolean supports concurrent reading and writing
    private AtomicBoolean mIsServiceDestroy = new AtomicBoolean( false ); 
 
    private Binder mBinder = new ILibraryManager.Stub() {
 ......
 @Override
 public void register(IOnNewBookArrivedListener listener) throws RemoteException {
            mListenerList.register(listener);
            Log.e(TAG, "register success" );
 } 
 
 @Override
 public void unregister(IOnNewBookArrivedListener listener) throws RemoteException {
            mListenerList.unregister(listener);
            Log.e(TAG, "unregister success" );
 }
 }; 
 
 ....... 
 
 @Override
 public void onCreate() {
 super.onCreate();
 ...... 
       
        new Thread(new Runnable() {
 @Override
 public void run() {
 // If the service has not terminated
                while (!mIsServiceDestroy.get()) {
 try {
                        Thread.sleep(10 * 1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
 } 
 
                    Book book = new Book( "book" + mBookList. size ());
                    mBookList.add (book);
                    bookArrivedNotify(book);
 }
 }
 }).start();
 } 
     
    private void bookArrivedNotify(Book book) {
 int n = mListenerList.beginBroadcast();
 for ( int i = 0; i < n; i++) {
            IOnNewBookArrivedListener listener = mListenerList.getBroadcastItem(i);
            if (listener != null ) {
 try {
                    listener.onNewBookArrived(book);
                } catch (RemoteException e) {
                    e.printStackTrace();
 }
 }
 }
        mListenerList.finishBroadcast();
 } 
 
 @Override
 public void onDestroy() {
 super.onDestroy();
        mIsServiceDestroy.set ( true ) ;
 }
 }

The RemoteCallbackList class is used here. It is a class provided by the system specifically for deleting cross-process listeners. It is difficult to ensure that the listener registered by the client and the listener stored by the server are the same using ordinary collections, which will cause the registration to fail.

Client code modification

 public class AIDLActivity extends AppCompatActivity {
 ......
    private ILibraryManager mLibraryManager; 
 
    private Handler mHandler = new Handler(new Handler.Callback() {
 @Override
 public boolean handleMessage(Message msg) {
            switch (msg.what) {
 case MESSAGE_NEW_BOOK_ARRIVED:
                    Log.e(TAG, "new book:" + msg.obj);
 break;
 }
 return   true ;
 }
 }); 
 
    private IOnNewBookArrivedListener listener = new IOnNewBookArrivedListener.Stub() {
 @Override
 public void onNewBookArrived(Book book) throws RemoteException {
 // Since the onNewBookArrived method is called in the child thread, the Handler is used to switch to the UI thread to facilitate UI operations
            mHandler.obtainMessage(MESSAGE_NEW_BOOK_ARRIVED, book).sendToTarget();
 }
 }; 
 
    private ServiceConnection mServiceConnection = new ServiceConnection() {
 @Override
 public void onServiceConnected(ComponentName name , IBinder service) {
            ILibraryManager libraryManager = ILibraryManager.Stub.asInterface(service);
            mLibraryManager = libraryManager;
 try {
 ......
 //Register notification
                libraryManager.register(listener);
            } catch (RemoteException e) {
                e.printStackTrace();
 }
 }
 ......
 }; 
 
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_aidl);
 bindNewService();
 } 
 
 @Override
    protected void onDestroy() {
        unbindService(mServiceConnection);
        if (mLibraryManager != null && mLibraryManager.asBinder().isBinderAlive()) {
 try {
 // Unregister
                mLibraryManager.unregister(listener);
            } catch (RemoteException e) {
                e.printStackTrace();
 }
 }
 super.onDestroy();
 }
 }

3. Messenger communication

Messenger is a lightweight multi-process communication method. It is encapsulated based on AIDL and can be regarded as a simplified version of AIDL. It supports one-to-many serial real-time communication.

Only one request is processed at a time, and there is no concurrency problem. Similar to the use of AIDL, but much simpler, and also requires the implementation of the server and client.

First, let's look at the server

 public class MessengerService extends Service {
    private static final String TAG = "MessengerService" ;
 // Associate the Messenger with the Handler
    private Messenger mServiceMessenger = new Messenger(new MessengerHandler()); 
 
 public MessengerService() {
 } 
 
 @Override
 public IBinder onBind(Intent intent) {
 return mServiceMessenger.getBinder();
 } 
 
    private static class MessengerHandler extends Handler {
 @Override
 public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
 case MessengerActivity.MESSAGE_FROM_CLIENT:
 // Print the received client message
                    Log.e(TAG, "receive message from client:" + msg.getData().getString( "msg" ));
 // Reply a message to the client
                    Messenger clientMessenger = msg.replyTo;
                    Message message = Message.obtain();
                    message.what = MessengerActivity.MESSAGE_FROM_SERVICE;
                    Bundle bundle = new Bundle();
                    bundle.putString( "msg" , "I am fine, thank you!" );
                    message.setData(bundle);
 try {
                        clientMessenger.send(message);
                    } catch (RemoteException e) {
                        e.printStackTrace();
 }
 break;
 }
 }
 }
 }

See the client implementation

 public class MessengerActivity extends AppCompatActivity {
    private static final String TAG = "MessengerActivity" ; 
 
 public   static final int MESSAGE_FROM_CLIENT = 1;
 public   static final int MESSAGE_FROM_SERVICE = 2; 
 
    private Messenger mServiceMessenger; 
 
    private Messenger mClientMessenger = new Messenger(new MessengerHandler()); 
 
    private ServiceConnection mServiceConnection = new ServiceConnection() {
 @Override
 public void onServiceConnected(ComponentName name , IBinder service) {
            mServiceMessenger = new Messenger(service);
            Message message = Message.obtain();
            message.what = MESSAGE_FROM_CLIENT;
            Bundle bundle = new Bundle();
            bundle.putString( "msg" , "how are you?" );
            message.setData(bundle);
 // Pass the Messenger that the server needs to use when replying to the client
            message.replyTo = mClientMessenger;
 try {
                mServiceMessenger.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
 }
 } 
 
 @Override
 public void onServiceDisconnected(ComponentName name ) { 
 
 }
 }; 
 
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger); 
 
        Intent intent = new Intent(MessengerActivity.this, MessengerService.class);
        bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
 } 
 
 @Override
    protected void onDestroy() {
        unbindService(mServiceConnection);
 super.onDestroy();
 } 
 
    private static class MessengerHandler extends Handler {
 @Override
 public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
 case MessengerActivity.MESSAGE_FROM_SERVICE:
                    Log.e(TAG, "receive message from service:" + msg.getData().getString( "msg" ));
 break;
 }
 }
 }
 }

In onServiceConnected(), convert the server-side Binder into a server-side Messenger object, and then send a message. Since the server needs to reply to the client, a Messenger object needs to be created on the client side and attached to the message and sent to the server for use.

Multi-process summary:

1. Multi-process apps can apply for multiple copies of memory in the system, but they should be used reasonably. It is recommended to put some high-consumption but infrequently used modules into independent processes, and unused processes can be manually closed in time;

2. Multiple processes occupy more memory and increase power consumption, so please pay attention to this;

3. When each process is created, the Application's onCreate will be executed for initialization. If there is no processing for different processes at this time, the onCreate initialization business will be executed multiple times, which is unnecessary and multiple initializations are prone to cause problems, so the corresponding business needs to be initialized according to different processes.

This article is reprinted from the WeChat public account "Android Development Programming". You can follow it through the following QR code. To reprint this article, please contact the Android Development Programming public account.