安卓IPC机制(一)

已于 2022-10-09 22:13:00 修改
阅读量754 收藏
点赞数 2
分类专栏： 安卓开发艺术探索学习 文章标签： android java
于 2022-10-09 22:11:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39216902/article/details/127235047
版权

🧭 安卓中的多进程模式

💡 多进程模式: 安卓可以通过android:process属性为四大组件开启多进程模式，若以:开头则属于该应用的子进程，否则是另外一个新进程。
注意：开启多进程后，安卓会为每一个应用开启一个独立虚拟机，或者说每一个进程都会有一个独立的虚拟机，不同的虚拟机在内存分配上有不同的地址空间，导致数据不共享。

使用多进程造成的问题：

  • 静态成员和单例模式完全失效；
  • 线程同步机制共享失败；
  • SharedPreferences的可靠性下降(SharedPreferences不支持两个进程同时去进行写操作，若如此会有一定几率导致数据丢失)；
  • Application会多次创建。

🔭 IPC基础概念介绍

1.序列化方式

💡 主要有Parcelable和Serializable接口，通过实现这两个接口可以实现序列化，总的来说，Parcelable的效率要高一些。

2.Binder

💡 Binder是安卓中的一种跨进程的通信方式，实现了IBinder接口，是安卓系统的通信的基石。
从Framework角度来说，Binder是ServiceManager连接各种Manager及相应ManagerService的桥梁，从Android应用层来说，Binder是客户端及服务端进行通信的媒介。当bindService时，服务端会返回包含服务端业务调用的Binder对象，客户端可以获取服务端说提供的服务或数据，这里的服务包括普通服务和AIDL服务。

以AIDL为例进行分析，新建以下代码文件：

//Book.java
package com.example.artandroidlearn;

import android.os.Parcel;
import android.os.Parcelable;

import androidx.annotation.NonNull;

public class Book implements Parcelable {

    public int bookId;
    public String bookName;

    public Book() {
    }

    public Book(int bookId, String bookName) {
        this.bookId = bookId;
        this.bookName = bookName;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(bookId);
        dest.writeString(bookName);
    }

    public static final Creator<Book> CREATOR = new Creator<Book>() {
        @Override
        public Book createFromParcel(Parcel in) {
            return new Book(in);
        }

        @Override
        public Book[] newArray(int size) {
            return new Book[size];
        }
    };

    protected Book(Parcel in) {
        bookId = in.readInt();
        bookName = in.readString();
    }

    @NonNull
    @Override
    public String toString() {
        return bookId + ":" + bookName;
    }
}

// Book.aidl
package com.example.artandroidlearn;

// Declare any non-default types here with import statements

parcelable Book;

// IBookManager.aidl
package com.example.artandroidlearn;
import com.example.artandroidlearn.Book;
import com.example.artandroidlearn.IonNewBookArrivedListener;

// Declare any non-default types here with import statements

interface IBookManager {
    /**
     * 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);
    List<Book> getBookList();
    void addBook(in Book book);
}

新建完上述代码后点击运行或编译，系统会根据IBookManager.aidl生成一个名为IBookManager.java 的binder接口，分析该代码并进行拆分：

  • IBookManager继承自android.os.IInterface接口；
  • 声明了IBookManager.aidl 的两个方法，如下所示：
/**
       * Demonstrates some basic types that you can use as parameters
       * and return values in AIDL.
       */
  public java.util.List<com.example.artandroidlearn.Book> getBookList() throws android.os.RemoteException;
  public void addBook(com.example.artandroidlearn.Book book) throws android.os.RemoteException;
  • 声明了两个内部类Default和Stub

Default类(该类作用未知，待研究)

public static class Default implements com.example.artandroidlearn.IBookManager
  {
    /**
         * Demonstrates some basic types that you can use as parameters
         * and return values in AIDL.
         */
    @Override public java.util.List<com.example.artandroidlearn.Book> getBookList() throws android.os.RemoteException
    {
      return null;
    }
    @Override public void addBook(com.example.artandroidlearn.Book book) throws android.os.RemoteException
    {
    }
    @Override
    public android.os.IBinder asBinder() {
      return null;
    }
  }
  • Stub类，Stub类里面有Proxy 类
public static abstract class Stub extends android.os.Binder implements com.example.artandroidlearn.IBookManager
  {
    private static final java.lang.String DESCRIPTOR = "com.example.artandroidlearn.IBookManager";
    /** Construct the stub at attach it to the interface. */
    public Stub()
    {
      this.attachInterface(this, DESCRIPTOR);
    }
    /**
     * Cast an IBinder object into an com.example.artandroidlearn.IBookManager interface,
     * generating a proxy if needed.
     */
    public static com.example.artandroidlearn.IBookManager asInterface(android.os.IBinder obj)
    {
      if ((obj==null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin!=null)&&(iin instanceof com.example.artandroidlearn.IBookManager))) {
        return ((com.example.artandroidlearn.IBookManager)iin);
      }
      return new com.example.artandroidlearn.IBookManager.Stub.Proxy(obj);
    }
    @Override public android.os.IBinder asBinder()
    {
      return this;
    }
    @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
    {
      java.lang.String descriptor = DESCRIPTOR;
      switch (code)
      {
        case INTERFACE_TRANSACTION:
        {
          reply.writeString(descriptor);
          return true;
        }
        case TRANSACTION_getBookList:
        {
          data.enforceInterface(descriptor);
          java.util.List<com.example.artandroidlearn.Book> _result = this.getBookList();
          reply.writeNoException();
          reply.writeTypedList(_result);
          return true;
        }
        case TRANSACTION_addBook:
        {
          data.enforceInterface(descriptor);
          com.example.artandroidlearn.Book _arg0;
          if ((0!=data.readInt())) {
            _arg0 = com.example.artandroidlearn.Book.CREATOR.createFromParcel(data);
          }
          else {
            _arg0 = null;
          }
          this.addBook(_arg0);
          reply.writeNoException();
          return true;
        }
        default:
        {
          return super.onTransact(code, data, reply, flags);
        }
      }
    }
    private static class Proxy implements com.example.artandroidlearn.IBookManager
    {
      private android.os.IBinder mRemote;
      Proxy(android.os.IBinder remote)
      {
        mRemote = remote;
      }
      @Override public android.os.IBinder asBinder()
      {
        return mRemote;
      }
      public java.lang.String getInterfaceDescriptor()
      {
        return DESCRIPTOR;
      }
      /**
           * Demonstrates some basic types that you can use as parameters
           * and return values in AIDL.
           */
      @Override public java.util.List<com.example.artandroidlearn.Book> getBookList() throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        java.util.List<com.example.artandroidlearn.Book> _result;
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          boolean _status = mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            return getDefaultImpl().getBookList();
          }
          _reply.readException();
          _result = _reply.createTypedArrayList(com.example.artandroidlearn.Book.CREATOR);
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
        return _result;
      }
      @Override public void addBook(com.example.artandroidlearn.Book book) throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          if ((book!=null)) {
            _data.writeInt(1);
            book.writeToParcel(_data, 0);
          }
          else {
            _data.writeInt(0);
          }
          boolean _status = mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            getDefaultImpl().addBook(book);
            return;
          }
          _reply.readException();
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
      }
      public static com.example.artandroidlearn.IBookManager sDefaultImpl;
    }

💡 当客户端和服务端位于同一个进程的时候，不会走Stub的transact过程，否则，则会调用transact过程，而具体逻辑则由Stub的内部代理类Proxy来完成。需要注意的是，跨进程通信主要是Stub类和其内部代理类Proxy来完成。

2.1 Stub类分析

  • Stub() :构造器，创建以DESCRIPTOR 为名称的Binder对象
public Stub()
    {
      this.attachInterface(this, DESCRIPTOR);
    }
  • DESCRIPTOR ：Binder 的唯一标识，一般用类名表示；另外两个是方法ID
private static final java.lang.String DESCRIPTOR = "com.example.artandroidlearn.IBookManager";

static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
  • asInterface 方法：将服务端的Binder对象转换成客户端所需要的AIDL接口类型的对象，其转换是区分进程的，若客户端和服务端位于同一个进程，则返回服务端Stub本身，否则直接返回Stub.Proxy对象。
/**
     * Cast an IBinder object into an com.example.artandroidlearn.IBookManager interface,
     * generating a proxy if needed.
     */
    public static com.example.artandroidlearn.IBookManager asInterface(android.os.IBinder obj)
    {
      if ((obj==null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin!=null)&&(iin instanceof com.example.artandroidlearn.IBookManager))) {
        //返回服务端Stub对象
				return ((com.example.artandroidlearn.IBookManager)iin);
      }
			//返回Stub.Proxy对象
      return new com.example.artandroidlearn.IBookManager.Stub.Proxy(obj);
    }
  • asBinder() ：返回当前的Binder对象
@Override public android.os.IBinder asBinder()
    {
      return this;
    }
  • onTransact :此方法运行在服务端的Binder线程池中，客户端发起跨进程请求时，远程请求通过系统底层封装后，由此方法处理。注意onTransact 方法返回false 代表客户端请求失败
/**
*code：表明请求方法是什么
*data: 目标方法所需要的参数，若目标方法有参数的话，则会从该参数里面获取参数
*reply:目标方法执行完之后，通过写入到该参数里面返回
*flags:Additional operation flags. Either 0 for a normal RPC,
*      or FLAG_ONEWAY for a one-way RPC.
**/

@Override public boolean onTransact(int code, android.os.Parcel data, 
					android.os.Parcel reply, int flags) throws android.os.RemoteException
    {
      java.lang.String descriptor = DESCRIPTOR;
      switch (code)
      {
        case INTERFACE_TRANSACTION:
        {
          reply.writeString(descriptor);
          return true;
        }
        case TRANSACTION_getBookList:
        {
          data.enforceInterface(descriptor);
          java.util.List<com.example.artandroidlearn.Book> _result = this.getBookList();
          reply.writeNoException();
          reply.writeTypedList(_result);
          return true;
        }
        case TRANSACTION_addBook:
        {
          data.enforceInterface(descriptor);
          com.example.artandroidlearn.Book _arg0;
          if ((0!=data.readInt())) {
            _arg0 = com.example.artandroidlearn.Book.CREATOR.createFromParcel(data);
          }
          else {
            _arg0 = null;
          }
          this.addBook(_arg0);
          reply.writeNoException();
          return true;
        }
        default:
        {
          return super.onTransact(code, data, reply, flags);
        }
      }
    }
  • sDefaultImpl 的set和get方法，这里面*sDefaultImpl* 方法是IBookManager 的一个对象本身
public static boolean setDefaultImpl(com.example.artandroidlearn.IBookManager impl) {
      // Only one user of this interface can use this function
      // at a time. This is a heuristic to detect if two different
      // users in the same process use this function.
      if (Stub.Proxy.sDefaultImpl != null) {
        throw new IllegalStateException("setDefaultImpl() called twice");
      }
      if (impl != null) {
        Stub.Proxy.sDefaultImpl = impl;
        return true;
      }
      return false;
    }
    public static com.example.artandroidlearn.IBookManager getDefaultImpl() {
      return Stub.Proxy.sDefaultImpl;
    }
  • Proxy :内部策略类：客户端本地的Binder对象，这里面实现了在IBookManager 里面定义的方法，通过调用transact 方法最后调用到了onTransact 方法实现了客户端和服务端的通信。
private static class Proxy implements com.example.artandroidlearn.IBookManager
    {
      private android.os.IBinder mRemote;
      Proxy(android.os.IBinder remote)
      {
        mRemote = remote;
      }
      @Override public android.os.IBinder asBinder()
      {
        return mRemote;
      }
      public java.lang.String getInterfaceDescriptor()
      {
        return DESCRIPTOR;
      }
      @Override public java.util.List<com.example.artandroidlearn.Book> getBookList() throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        java.util.List<com.example.artandroidlearn.Book> _result;
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          boolean _status = mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
          //若_status为false表明客户端请求失败，调用客户端本地实现的方法
					if (!_status && getDefaultImpl() != null) {
            return getDefaultImpl().getBookList();
          }
          _reply.readException();
          _result = _reply.createTypedArrayList(com.example.artandroidlearn.Book.CREATOR);
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
        return _result;
      }
      @Override public void addBook(com.example.artandroidlearn.Book book) throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          if ((book!=null)) {
            _data.writeInt(1);
            book.writeToParcel(_data, 0);
          }
          else {
            _data.writeInt(0);
          }
          boolean _status = mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            getDefaultImpl().addBook(book);
            return;
          }
          _reply.readException();
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
      }
      public static com.example.artandroidlearn.IBookManager sDefaultImpl;
    }

💡 注意客户端发起请求时，当前线程会被挂起直到服务端进程返回数据，因此如果远程请求是耗时方法则不能通过UI线程发起此远程请求，另外，由于服务端的Binder方法运行在Binder线程池中，因此Binder方法不管是否耗时都应该采取同步的方式去实现。

综上，Binder工作机制及流程

在这里插入图片描述

根据系统由aidl生成IBookManager.java方式，用自己的方式进行改写,如下，改写完的基本和原来一致，但是可以不用通过aidl的方式生成：

package com.example.artandroidlearn;

import android.os.IInterface;

public interface IBookManager1 extends IInterface {
    public static final String DESCRIPTOR = "com.example.learnartandroid.IBookManager";
    static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);

    public java.util.List<com.example.artandroidlearn.Book> getBookList() throws android.os.RemoteException;

    public void addBook(com.example.artandroidlearn.Book book) throws android.os.RemoteException;
}

package com.example.artandroidlearn;

import android.os.Binder;
import android.os.IBinder;
import android.os.IInterface;
import android.os.Parcel;
import android.os.RemoteException;

import java.util.List;

public class BookManagerImpl extends Binder implements com.example.artandroidlearn.IBookManager1 {

    public BookManagerImpl() {
        this.attachInterface(this, DESCRIPTOR);
    }

    public static com.example.artandroidlearn.IBookManager1 asInterface(IBinder obj) {
        if (obj == null) {
            return null;
        }
        IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
        if (iin != null && iin instanceof BookManagerImpl) {
            return (com.example.artandroidlearn.IBookManager1) obj;
        }
        return new Proxy(obj);
    }

    @Override
    public List<Book> getBookList() throws RemoteException {
        return null;
    }

    @Override
    public void addBook(Book book) throws RemoteException {

    }

    @Override
    public IBinder asBinder() {
        return this;
    }

    @Override
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
        String descriptor = DESCRIPTOR;
        switch (code) {
            case INTERFACE_TRANSACTION: {
                reply.writeString(descriptor);
                return true;
            }
            case TRANSACTION_getBookList: {
                data.enforceInterface(descriptor);
                List<com.example.artandroidlearn.Book> result = this.getBookList();
                reply.writeNoException();
                reply.writeTypedList(result);
                return true;
            }
            case TRANSACTION_addBook: {
                data.enforceInterface(descriptor);
                com.example.artandroidlearn.Book _arg0;
                if ((0 != data.readInt())) {
                    _arg0 = com.example.artandroidlearn.Book.CREATOR.createFromParcel(data);
                } else {
                    _arg0 = null;
                }
                this.addBook(_arg0);
                reply.writeNoException();
                return true;
            }
            default: {
                return super.onTransact(code, data, reply, flags);
            }
        }
    }

    private static class Proxy implements com.example.artandroidlearn.IBookManager1 {

        private IBinder mRemote;

        public Proxy(IBinder mRemote) {
            this.mRemote = mRemote;
        }

        public String getInterfaceDescriptor() {
            return DESCRIPTOR;
        }

        @Override
        public List<Book> getBookList() throws RemoteException {
            Parcel data = Parcel.obtain();
            Parcel reply = Parcel.obtain();
            List<Book> result;
            try {
                data.writeInterfaceToken(DESCRIPTOR);
                mRemote.transact(TRANSACTION_getBookList, data, reply, 0);
                reply.readException();
                result = reply.createTypedArrayList(Book.CREATOR);
            } finally {
                reply.recycle();
                data.recycle();
            }
            return result;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            Parcel data = Parcel.obtain();
            Parcel reply = Parcel.obtain();
            try {
                data.writeInterfaceToken(DESCRIPTOR);
                if (book != null) {
                    data.writeInt(1);
                    book.writeToParcel(data, 0);
                } else {
                    data.writeInt(0);
                }
                mRemote.transact(TRANSACTION_addBook, data, reply, 0);
                reply.readException();
            } finally {
                reply.recycle();
                data.recycle();
            }

        }

        @Override
        public IBinder asBinder() {
            return mRemote;
        }
    }
}
whl_better
关注
专栏目录
Android 中的IPC机制
Kevin的专栏
04-15 1万+
Android IPC 介绍IPC是 Inter-Proscess Communication的缩写，含义为进程间的通讯或者跨进程通讯，是指两个进程之间进行数据交换的过程。按操作系统的中的描述，线程是CPU调度最小的单元，同时线程是一种有限的系统资源，而进程是指一个执行单元，在PC和移动设备上指一个程序或者一个应用。一个进程可以包含多个线程，因此进程和线程是包含于被包含的关系。IPC的使用场景就必须
Android IPC机制总结（png图）
04-21
Android IPC机制总结,概念,使用场景,开启多进程模式,运行机制,优缺点以及场景等等
理论修炼---初窥Android IPC机制
潘潘
07-20 584
理论修炼---初窥Android IPC机制
Android IPC编程简介
gogor的专栏
07-27 7986
一、Android IPC机制简介1、Android进程/线程简介     在Android系统里，一个应用程序通常包含多个组件（如Activity、Service等），这些组件既可以在同一个进程中，也可以在不同的进程中。默认情况下，一个应用程序的多个组件均位于同一进程（主进程）
Android中的IPC机制
weixin_30521161的博客
01-22 100
Android IPC简介 IPC是Inter-Process Communication的缩写，含义就是进程间通信或者跨进程通信，是指两个进程之间进行数据交换的过程。那么什么是进程，什么是线程，进程和线程是两个截然不同的概念。在操作系统中，线程是CPU调度的最小单元，同时线程是一种有限的系统资源。而进程指的一个执行单元，在PC和移动设备上指的是一个程序或者一个应用。一个进程可以包含多个线程，因此...
安卓IPC机制(二)
qq_39216902的博客
10-12 392
安卓IPC机制学习
AndroidIPC, 各种 Android IPC机制示例.zip
09-18
AndroidIPC, 各种 Android IPC机制示例 AndroidIPC各种 Android IPC机制示例构建和运行你需要来自adb的root 许可$ ndk-build$ adb push libs/armeabi-v7a/ipc/data/local/$ a
Android IPC机制demo
05-21
本文将深入探讨Android IPC机制，并通过具体的ContentProvider和Socket通信实例进行详细解析。 首先，理解Android IPC的重要性是至关重要的。由于Android系统采用严格的权限隔离，每个应用运行在自己的进程中，这...
Android IPC机制Messenger实例详解
08-29
Android IPC机制Messenger实例详解是Android操作系统中的一种进程间通信机制，通过Messenger对象可以在不同进程间传递Message对象，从而实现进程间的数据传递。Messenger使用的方法相对AIDL比较简单，它对AIDL做了...
android中IPC机制简介
Ueming的博客
10-25 1547
除了Binder，Android还支持Socket，通过Socket也可以实现任意两个终端之间的通信，当然同一个设备上的两个进程通过Socket通信也自然是可以的。什么是进程，进程和线程是截然不同的概念。按照操作系统中的描述，线程是cpu调度最小的单元，同时线程是一个有限的系统资源。IPC是Inter-Process Communication的缩写，含义为进程间通信或者跨进程通信，是指两个进程间进行数据交换的过程。最简单情况下，一个进程中可以只有一个线程，即主线程，安卓中为UI线程。
安卓IPC机制
weixin_50961942的博客
10-24 2114
IPC是Inter-Process Communication的缩写，含义是进程间通信，用于两个进程之间进行数据交互的过程，任何操作系统都有IPC机制，但不同的操作系统有着不同的通信方式，Android系统是一种基于Linux内核的移动操作系统，Linux的跨进程通信主要通过管道、共享内存、内存映射等实现的，但Android有自己的进程间通信机制，最具代表性的就是Binder。线程：CPU调度的最小单元，是一种有限的资源。
Android IPC分析
hgl868的专栏
10-04 8785
说到Android的IPC（Inter-Process Conmmunication）首先想到的就是Handler和Looper，Handler用于多进程之间的通信和数据交换，将各进程之间通信的数据Message放置到Message Queue里，而Looper用于创建各进程自身
Android IPC
walkeryu
11-26 320
1.Android IPC介绍 IPC是Inter-Process Communication的缩写，含义为进程间的通信或者跨进程通信，指的是两个进程之间进行数据交换的过程。首先，我们要区分一下&amp;amp;quot;进程&amp;amp;quot;和&amp;amp;quot;线程&amp;amp;quot;。按照操作系统的描述，线程是CPU调度的最小单元，同时线程是一中有限的资源。进程一般指一个执行单元，在PC和移动设备上指一个程序或者一个应用。一个进程可以包含多个线
android的IPC机制
深红骑士的博客
10-15 2040
IPC不是android中独有的，任何一个操作系统都需要相应的IPC机制，比如Window上可以通过剪贴板，管道和邮槽来进行进程间通信；Linux上可以通过命名管道、共享内存、信号量等进行进程间通信，可以看到不同的操作系统平台有着不同的进程间通信方式。对于Android来说，它是一种基于Linux内核的移动操作系统，它的进程间通信方式不能完全继承自LInux，相反，它有自己的进程间通信方式，最有特
Android IPC机制
最新发布
xiaokangss的博客
03-28 899
线程：线程是CPU调度的最小单位，是一种有限的系统资源。 进程：进程一般指一个执行单元，在PC或者移动设备上指一个程序或者应用。 一个进程可以包含多个线程，最简单情况下，一个进程只包含一个线程（即主线程）。Android中主线程也叫作UI线程。
Android中级——IPC
松仔Log的博客
07-05 1334
当Binder所在服务端进程异常终止时，会导致远程调用失败，通过linkToDeath()可为Binder设置一个死亡代理，当Binder死亡时回调binderDied()可再次重新发起请求。在AS菜单栏的Build，点击Clean Project，再点击Rebuild Project，会生成IBookManager.java，位置如下图。Messenger只能串行处理客户端的请求，当需要并行处理客户端请求或需要调用服务端的方法时可以使用AIDL，AIDL支持的数据类型有。
安卓IPC机制学习
子敬的技术博客
03-31 294
安卓IPC机制学习 参考： https://my.oschina.net/keeponmoving/blog/64218 http://blog.csdn.net/luoshengyang/article/details/6618363 http://blog.cgsdream.org/2015/11/09/binder-analysis/ IPC机制： 是什么： IPC是Int
安卓IPC机制（一）---基础
sakurakider的博客
08-13 1590
吐槽 中午不想起来啊啊啊，但是不起来又不行，唉，坚持坚持，这个世界不会因为我一个人的懒惰而不转的。 参考任玉刚老师的《Android开发艺术探索》 Android IPC简介 IPC是进程间的通信或者跨进程通信，是指两个进程之间的进行数据交换的过程 Bundle、文件共享、AIDL（Android Interface definition language一种android内部进程通信接...
Android IPC机制深入解析
"Android IPC机制详解，包括IBinder接口、transact函数、客户端（BpBinder）与服务端的交互过程" Android IPC（Inter-Process Communication）是Android系统中用于不同进程间通信的一种机制，它是Android应用程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值