Android的IPC:Binder

Android 进阶——Binder IPC之Binder IPC架构及原理概述(九) Binder IPC之学习Binder IPC架构及原理。 阅读详情

IPC是一种概念:进程间的通信,有很多实现方法,例如android系统内的binder、contentProvider等

  • 一个进程中可以有多个线程,也可以只有一个线程,在android系统中,这唯一的线程就是主线程,即UI线程,用来操作界面元素
  • android系统对每个应用都有内存限制,如果需要扩大内存就可以通过创建新进程来获取更大内存

一个应用内的多进程 --- android:process

android系统中,一个应用内使用多进程方法,给四大组件定义属性android:process,还有一种就是native层的fork新进程

  • 实例
        <activity android:name=".MainActivity"
            android:excludeFromRecents="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name=".secondActivity"
            android:process=":remote">
            <intent-filter>
                <action android:name="secondactivity" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </activity>

        <activity android:name=".thirdActivity"
            android:process="com.app.typicallifecycle.remote">
            <intent-filter>
                <action android:name="thirdactivity" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </activity>
    </application>

结果:成功创建出两个新进程
:代表当前应用的私有进程,其他应用组件不可以和它跑在一个进程中
没用到:代表是全局进程,可以通过ShareUID的方式跑在一个进程中(还需要签名相同)

系统会为每一个应用分配一个UID,通过UID可以共享应用数据

u0_a30    9930  182   927684 42572 ffffffff b764535b S com.app.typicallifecycle
u0_a30    9956  182   931808 40108 ffffffff b764535b S com.app.typicallifecycle:remote
u0_a30    9969  182   936668 39852 ffffffff b764535b S com.app.typicallifecycle.remote

多进程的运行机制的一些问题

  • 实例:
  1. 定一个有静态变量的类
public class userProcess {
    public static int number=0;
}
  1. 在MainActivity中自加1,然后日志输出、接着去sencondactivity中输出这个静态变量,看结果,sencondactivity中的值依然是0
11-30 17:33:42.524 10189-10189/? E/xxxxx: number的值为1
11-30 17:33:45.244 10215-10215/com.app.typicallifecycle:remote E/xxxxx: number的值为0

为什么会出现这种情况?

  • Android系统为每个应用(进程)分配一个虚拟机
  • 每个虚拟机使用的内存地址是不一样的,所以依靠内存地址进行数据共享不会成功的。也就是这个两个进程中都有一个userProcess 类,他们互不干扰

多进程常出现的问题:

  1. 静态类、单例模式失效(如上)
  2. SharedPreference可靠性下降:SharedPreference是不支持两个进程同时的写操作的(底层是对xml文件的读写,并发读写是会出问题的)
  3. Application重复创建:为组件创建新进程,首先创建虚拟机、然后创建相应的应用,然后启动组件。具体实现如下
    将这个myApplication 放入AndroidManifest文件,作为应用的实现类
public class myApplication extends Application {
    private static Context context;
    private int processID;

    @Override
    public void onCreate() {
        context = getApplicationContext();
        processID = Process.myPid();
        Log.e("process", String.valueOf(processID));
        super.onCreate();
    }

开启,活动的时候,这个应用被创建了多次

11-30 18:09:10.814 10762-10762/com.app.typicallifecycle E/process: 10762
11-30 18:09:11.894 10788-10788/com.app.typicallifecycle:remote E/process: 10788
11-30 18:09:14.584 10801-10801/com.app.typicallifecycle.remote E/process: 10801

多进程一些方法

即使多进程有一些问题,当时依然可以被克服,这就是Ibinder、Intent,先引入基础,序列化和反序列化

Serializable
用法:随意声明一个类继承Serializable接口,它内部的属性就可以实例化

public class userProcess implements Serializable {
    private static final long serialVersionUID=111;
    public String fater;
    public String getFater() {
        return fater;
    }
    public void setFater(String fater) {
        this.fater = fater;
    }
}

具体序列化和反序列化过程
        //序列化过程
        userProcess u1 = new userProcess();
        u1.setFater("father007");
        try {
            File file = new File("/sdcard/cache.txt");
            ObjectOutputStream objoutput = new ObjectOutputStream(new FileOutputStream(file));
            objoutput.writeObject(u1);
            objoutput.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        //反序列化过程
        try {
            FileInputStream filein = new FileInputStream(new File("/sdcard/cache.txt"));
            ObjectInputStream objIN = new ObjectInputStream(filein);
            userProcess u1 = (userProcess) objIN.readObject();
            Log.e("userprocess", u1.getFater());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

serialVersionUID:需要的注意一个属性,是一个类的HASH值。

  1. 序列化和反序列化过程中的标识码,如果这个值在序列化和反序列化的过程中不一样,是不能成功反序列化的
  2. 这个UID是保证这样一种情况的,当序列化完一个对象到本地后,过了一段时间要进行反序列化的时候,由于这个被序列化的类属性发生了更改,如果是默认标识码的话,这个hash值会更改,就会失败,但是如果手动设置好固定的serialVersionUID,就可以尽量避免这种情况,但是如果类的改动过大,还是出问题的。
    例如:
序列化之前的类:
public class userProcess implements Serializable {
    private static final long serialVersionUID=111;
    public String fater;
    public String getFater() {
        return fater;
    }
    public void setFater(String fater) {
        this.fater = fater;
    }
}
序列化完后,对这个类的属性进行了更改,多了一个son属性,但是其他没什么改变,这个小改动,并且没有改变被序列化的属性,是不会影响反序列化的
    private static final long serialVersionUID=110;
    public static int number=0;
    public String fater;
    public String son;

但是如果改动的是fater这个属性的化就会出问题,因为这个属性是被序列化的属性,如果类属性更改,就会出现不匹配,报出异常
    public int fater;

Parcelable
另一种序列化的接口,实现序列化之后可以通过Intnet、Binder传输序列化对象。
他的具体是实现是:将序列化和反序列化都封装在一个接口中

简单的实例

public class userProcess implements Parcelable {

    private String father;
    private int son;
    private Boolean mom;
    public String getFather() {
        return father;
    }

    public int getSon() {
        return son;
    }

    public Boolean getMom() {
        

    //描述信息,基本上都是返回0
    @Override
    public int describeContents() {
        return 0;
    }


    /*
    先实例化对象,然后序列化对象
     */
    public userProcess(String f, int s, Boolean m){
        father=f;
        son=s;
        mom=m;
    }

    //序列化过程
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(father);
        dest.writeInt(son);
        //bool型数据用int存储
        dest.writeInt(mom ? 1 : 0);
    }


    //反序列化过程
    public static final Creator<userProcess> CREATOR = new Creator<userProcess>() {
        @Override
        public userProcess createFromParcel(Parcel in) {
            return new userProcess(in);
        }

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

    protected userProcess(Parcel in) {
        father=in.readString();
        son=in.readInt();
        mom=in.readInt()==1;
    }
}

Serializable和Parcelable的区别:Serializable是java提供的序列化接口,存在许多I/O操作,消耗比Parcelable大,建议使用于本地持久化也就是往本地存数据等方面。而Parcelable是android提供的,使用虽然比serializable复杂点,但是更高效一些

Binder

从哪来::继承iBinder接口,是其实现类
到哪去::1. 在android framwork里,它是连接各种manager的桥梁 2.在Application层:他是客户端和服务端通信的媒介(这里的客户端和服务端可以看作同一App内的两个进程,也可以看作同一厂家的不同App),服务端返回一个binder给客户端,通过binder让其访问服务端的资源和服务 ,主要应用于同一个App内的跨进程通信,下面从AIDL看binder

这里引入了一个概念AIDL:android接口定义语言

为什么使用它?

官网解释:注:只有允许不同应用的客户端用 IPC 方式访问服务,并且想要在服务中处理多线程时,才有必要使用 AIDL。 如果您不需要执行跨越不同应用的并发 IPC,就应该通过实现一个 Binder 创建接口;或者,如果您想执行 IPC,但根本不需要处理多线程,则使用 Messenger 类来实现接口

Android:学习AIDL,这一篇文章就够了(上)

简单的实例:
先右键new 一个AIDL file,下面我只定义了一个方法,用来获取PID:int getPID();

// IMyAidlInterface.aidl
package com.app.typicallifecycle;

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

interface IMyAidlInterface {

    int getPID();
    /**
     * 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);
}

然后点击菜单build->rebuild project就可以手动利用gradle在build/generated/source/aidl/包名/IMyAidlInterface.java方法,构建相应接口的java文件并且会在内部自动填写int getPID();。这个文件内部有一个子类,是继承Binder类的,即IMyAidlInterface.sub这个类的实例就是具体客户端和服务端传递数据、服务的传输工具

public static abstract class Stub extends android.os.Binder implements com.app.typicallifecycle.IMyAidlInterface

ibinder = IMyAidlInterface.Stub.asInterface(service);:主要这一步,将ibinder对象转成IMyAidlInterface类型对象,否则跨进程的时候会报错,不跨进程不会出错,因为不跨进程,服务启动之后就在这个进程中,直接返回一个IMyAidlInterface.Sub类,当然没问题了。但是如果服务开启在另一个进程中,返回的是一个BinderProxy类,是不能强转程IMyAidlInterface.Sub类的,所以需要asInterface方法来转化

客户端关键代码
 private ServiceConnection myserviceconnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //连接上服务的回调函数
            Log.e("xxxxx", name.getClassName());
            ibinder = IMyAidlInterface.Stub.asInterface(service);
            try {
                int pid =  ibinder.getPID();
                Log.e("xxxxx", "pid等于"+ pid);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            //断开连接的回调函数
        }
    };

bindService(new Intent("AIDLservice"), myserviceconnection, BIND_AUTO_CREATE);
记住别忘了在AndroidManifest.xml中注册服务组件

Android 接口定义语言 (AIDL)

稍微复杂的实例:
引入自定义类Book类,也就是说需要过进程传输这个对象。引入这个自定义类之前我们需要知道,AIDL文件有很多系统默认的基础类是可以序列化的,所以我们这个自定义类也需要序列化,并且生成一个aidl文件,供给其他aidl文件使用

13671484-4be12492cf5dcc44.png
目录结构

  1. 先自定Book类
package com.app.typicallifecycle;
import android.os.Parcel;
import android.os.Parcelable;

public class Book implements Parcelable {
    private int BookID;
    private String BookName;

    public Book(int bookid, String bookname){
        BookID = bookid;
        BookName = bookname;
    }

    //序列化
    @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();
    }
    @Override
    public int describeContents() {
        return 0;
    }
}
  1. 生成aidl文件,让其他aidl接口文件使用
    必须:New->file,不要new一个AIDL文件,android studio会识别会接口文件,在generated目录下生成java文件
package com.app.typicallifecycle;
parcelable Book;
  1. 接口文件:将需要给客户端使用的功能接口,数据接口都在这定义
    这里有个点需要注意:in Book book,从客户端传参数到服务端,数据流向是从客户端到服务端,用in。如果是数据流向流向服务端就用out,即服务端数据更改,服务端也跟着更改,但是如果这是向服务端传数据,就是空对像。双向流通inout。
// BookManager.aidl
package com.app.typicallifecycle;

// Declare any non-default types here with import statements
import com.app.typicallifecycle.Book;

interface BookManager {

    void addBooks(in Book book);
    Book getBook();

}

4.服务端

package com.app.typicallifecycle;

import com.app.typicallifecycle.Book;
public class AIDLService extends Service {


    private final BookManager.Stub bookManager = new BookManager.Stub() {
        @Override
        public void addBooks(Book book) throws RemoteException {
        }

        @Override
        public Book getBook() throws RemoteException {
            return null;
        }
    };

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return bookManager;
    }
}

这里需要注意一下,因为要用到Book这个自定义的类,但是这个类没有放在java包内,而且它默认是不检查main/aidl包内的java文件,需要手动加入,所以直接在build.gradle内android下加入如下代码即可:

sourceSets {
        main {
            java.srcDirs = ['src/main/java', 'src/main/aidl']
        }
    }

5.客户端:部分关键代码

    private ServiceConnection myserviceconnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //连接上服务的回调函数
            Log.e("xxxxx", name.getClassName());
            ibinder = BookManager.Stub.asInterface(service);
            Book book1 = new Book(007, "android艺术探索");
            try {
                ibinder.addBooks(book1);
                Log.e("xxxxx", "上传完第一本书:艺术探索");
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            try {
                 Book book;
                book = ibinder.getBook();
                Log.e("xxxxx", "下载完书籍:"+book);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            //断开连接的回调函数
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.e("xxxxx", "onCreate: 活动创建");
        super.onCreate(savedInstanceState);
        editText = findViewById(R.id.editText);
        setContentView(R.layout.activity_main);
        button = findViewById(R.id.button);

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                bindService(new Intent("AIDLservice"), myserviceconnection, BIND_AUTO_CREATE);
            }
        });
    }
13671484-6e8137a9152d1a2f.png

主要分析一下BookManager.java文件,他是android studio自动生成的,也是AIDL的目的所在,就是为了方便我们来写这种接口,这个文件存在不同进程通信的逻辑所在

首先客户端请求绑定另外一个进程的服务,来获取上传书籍和下载书籍的功能。服务端返回一个Binder对象来作为双方通信的桥梁。服务端把所有向客户端开放的接口都放在了proxy类下。将需要输入的参数有_data传递,将需要返回的数据由_reply传递,然后将请求通过transact传递到服务端

private static class Proxy implements com.app.typicallifecycle.BookManager
{
    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 void addBooks(com.app.typicallifecycle.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);
            }
            mRemote.transact(Stub.TRANSACTION_addBooks, _data, _reply, 0);
            _reply.readException();
        }
        finally {
            _reply.recycle();
            _data.recycle();
        }
    }
    @Override public com.app.typicallifecycle.Book getBook() throws android.os.RemoteException
    {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        com.app.typicallifecycle.Book _result;
        try {
            _data.writeInterfaceToken(DESCRIPTOR);
            mRemote.transact(Stub.TRANSACTION_getBook, _data, _reply, 0);
            _reply.readException();
            if ((0!=_reply.readInt())) {
                _result = com.app.typicallifecycle.Book.CREATOR.createFromParcel(_reply);
            }
            else {
                _result = null;
            }
        }
        finally {
            _reply.recycle();
            _data.recycle();
        }
        return _result;
    }
}

然后另一个进程上的服务端通过这个onTransact在线程池中的方法,来处理客户端的请求,从code获取客户端请求的方法、从data获取参数、如果有返回值通过reply返回,如果返回false表示请求失败,通过这个做了一个权限控制,有选择的允许访问

@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_addBooks:
{
    data.enforceInterface(descriptor);
    com.app.typicallifecycle.Book _arg0;
if ((0!=data.readInt())) {
    _arg0 = com.app.typicallifecycle.Book.CREATOR.createFromParcel(data);
}
else {
    _arg0 = null;
}
    this.addBooks(_arg0);
    reply.writeNoException();
    return true;
}
    case TRANSACTION_getBook:
{
    data.enforceInterface(descriptor);
    com.app.typicallifecycle.Book _result = this.getBook();
    reply.writeNoException();
if ((_result!=null)) {
    reply.writeInt(1);
    _result.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
}
else {
    reply.writeInt(0);
}
    return true;
}
    default:
{
    return super.onTransact(code, data, reply, flags);
}
}
}

然后就是将远程传递过来的binder对象转成客户端可以使用的binder对象通过asInterface方法

/**
 * Cast an IBinder object into an com.app.typicallifecycle.BookManager interface,
 * generating a proxy if needed.
 */
public static com.app.typicallifecycle.BookManager asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.app.typicallifecycle.BookManager))) {
    return ((com.app.typicallifecycle.BookManager)iin);
}
    return new com.app.typicallifecycle.BookManager.Stub.Proxy(obj);
}

还有一个asbinder方法用来获取当前binder
小结一下:其实上面的内容,不使用AIDL文件也可以实现,因为AIDL就是为了方便生成接口文件,如本例中的Manager.java,不过为了方便高效来说AIDL肯定更方便,手动写那么多代码也是挺累的

最后一个小点
由于跨进程通信,如果服务端出现问题终止了,客户端却不知到服务端的情况,有可能继续发起请求,但是这样有可能会影响客户端的运行,所以引入死亡代理这个概念。通过linkToDeath和unlinkToDeath,相关介绍可以看API上面的介绍linkToDeath是注册接收一个服务死亡时通知,unlinkToDeath是移除前面注册的死亡通知

绑定好远程服务,开启死亡代理service.linkToDeath(deathRecipient, 0);

    private ServiceConnection myserviceconnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //连接上服务的回调函数
            Log.e("xxxxx", name.getClassName());

            bookManager = BookManager.Stub.asInterface(service);
            try {
                service.linkToDeath(deathRecipient, 0);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            Book book1 = new Book(007, "android艺术探索");
            try {
                bookManager.addBooks(book1);
                Log.e("xxxxx", "上传完第一本书:艺术探索");
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            try {
                 Book book;
                book = bookManager.getBook();
                Log.e("xxxxx", "下载完书籍:"+book);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

这是一个Ibinder下的接口

        //死亡代理
        private IBinder.DeathRecipient deathRecipient = new IBinder.DeathRecipient() {
            @Override
            //如果服务端进程死掉,回调此方法
            public void binderDied() {
                Log.e("xxxxx","接受到死亡通知");
                //断开连接的回调函数
                if (bookManager==null)
                    return;
                //移除之前的死亡通知
                bookManager.asBinder().unlinkToDeath(deathRecipient, 0);
                //重新绑定服务
                bookManager=null;
                bindService(new Intent("AIDLservice"), myserviceconnection, BIND_AUTO_CREATE);
            }
        };

杀死进程名为app.service.remote的进程

                ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
                List<ActivityManager.RunningAppProcessInfo> processinfolist = activityManager.getRunningAppProcesses();
                for (int i=0; i<processinfolist.size(); i++){
                    String processName = processinfolist.get(i).processName;
                    if (processName.equals("app.service.remote")) {
                        int pid = processinfolist.get(i).pid;
                        Process.killProcess(pid);
                    }
Android Binder IPC分析 Binder IPC 机制是android非常重要的一种进程间通信机制,掌握了Binder IPC的原理,那么你基本上对Android有了50%的了解了。本文着重介绍了Binder的原理。 阅读详情

相关推荐

Android P的Binder IPC

一直以来,供应商进程都使用 Binder 进程间通信 (IPC) 技术进行通信。在 Android O 中,/dev/binder 设备节点成为了框架进程的专属节点,这意味着供应商进程将无法再访问该节点。供应商进程可以访问 /dev/hwbinder,但必须将其 AIDL 接口转为使用 HIDL。对于想要继续在供应商进程之间使用 AIDL 接口的供应商,Android 会按以下方式支持 Binde...

Vincentywj的博客 896

Android Framework跨进程通信IPC之6——Binder框架

Android 从下而上分了内核层、硬件抽象层、系统服务层、Binder IPC 层、应用程序框架层Android 中"应用程序框架层"以 SDK 的形式开放给开发者使用,“系统服务层” 中的核心服务随系统启动而运行,通过应用层序框架层提供的 Manager 实时为应用程序提供服务调用。系统服务层中每一个服务运行在自己独立的进程空间中,应用程序框架层中的 Manager 通过 Binder IPC 的方式调用系统服务层中的服务。简单的说,Binder是Android平台上的一种跨进程通信技术。

Gaga246的博客 5448

Android中APP、AMS、WMS的Binder IPC

APP、AMS、WMS的IPC是一个极其值得深入研究的过程。下面通过非常常见的startActivity来解析APP、AMS、WMS进程之间的通信过程。1.startActivity Binder IPC流程图 ServiceManager,AMS,WMS,SurfaceFlinger都是android系统服务,在前面《从底层看android5.0启动过程》一文中已经解析过,不清楚的可先浏览该文章

qq526459753的博客 3525

Android跨进程通信:图文详解 Binder机制 原理

前言 如果你接触过 跨进程通信 (IPC),那么你对Binder一定不陌生 虽然 网上有很多介绍 Binder的文章,可是存在一些问题:浅显的讨论Binder机制 或 一味讲解 Binder源码、逻辑不清楚,最终导致的是读者们还是无法形成一个完整的Binder概念 本文采用 清晰的图文讲解方式,按照 大角度 -&gt; 小角度 去分析Binder,即: 先从 机制、模型的角度 去分析 整个B...

Carson带你学Android 14万+

Linux下离线安装Google Chrome

目录背景一、下载并安装Google Chrome二、下载并安装依赖包1.libvulkan.so.1()(64bit)2.读入数据总结 背景 项目中服务器被要求不能连接外网,不能直接联网安装,所以需要下载Google Chrome安装包和依赖包,然后离线安装。 linux下步骤都一样,不管ubuntu还是centos只是需要下载对应系统的文件包即可。 本机系统:CentOS 7 一、下载并安装Google Chrome 官方下载地址http://www.google.cn/chrome/browser/d

ancientapesman的博客 1万+

具身智能四大技术路线:VLA、大小脑、世界模型与强化学习

具身智能是机器人实现感知-决策-执行闭环的核心范式,其本质在于物理世界中的具身化交互能力。技术演进围绕如何高效建模环境、理解指令并生成鲁棒动作展开,衍生出四大主流路径:视觉-语言-动作(VLA)端到端学习、大小脑分层控制、世界模型驱动预测,以及强化学习原生策略优化。VLA强调多模态对齐与泛化能力,适合语义理解优先场景;大小脑架构兼顾实时性与可解释性,是工业落地的高可靠选择;世界模型追求内在物理模拟,代表长期认知跃迁方向;强化学习则扎根仿真试错,在力控、抓取等连续控制任务中展现强鲁棒性。本文聚焦这四大路线的技

weixin_32181267的博客 300

Android Framwork 之深入理解 IPC Binder机制

我们都知道 Android 系统分成三层。最上层是 application 应用层,第二层是 Framework 层,第三层是 native 层。Android 应用和系统 Service 运行在不同进程中是为了安全、稳定以及内存管理的原因,但是应用和系统服务需要通信和分享数据。跨进程设计的好处:1.安全性:每个进程都单独运行的,可以保证应用层对系统层的隔离。2.稳定性:如果某个进程崩溃了不会导致其他进程崩溃。3.内存分配:如果某个进程以及不需要了可以从内存中移除,并且回收相应的内存。

Bonnie_cat的博客 1342

计量经济学tempdisagg的python库:年度时序变月度

计量经济学tempdisagg的python库:年度时序变月度

素质云笔记 1536

Android Framework跨进程通信IPC之5——Binder的三大接口

本片文章的主要目的是让大家对Binder有个初步的了解,既然是初步了解,肯定所是以源码上的注释为主,让大家对Binder有一个更直观的认识。PS:大部分注释我是写在类里面了, 重要的我会单独的拿出来。主要内容如下:1、IInterface 2、IBinder 3、Binder与BinderProxy类 4、总结所以可以这样说IInterface接口提供了类型转化的功能,将服务或者服务代理类转为IBinder类型。

Gaga246的博客 1114

【STM32项目】基于STM32设计的震动马达超声波电机高频震动——高级定时器PWM互补输出带死区控制__资料编号3

实现高级定时器互补输出带死区控制,实现震动/超声波电机/马达,高频震动。使用 STM32F103 芯片输出两路互补 PWM,并带有死区和刹车控制功能。定时器 1 通道 1 及其互补通道输出PWM,且带死区控。当定时器 1 的刹车输入引脚被拉高时,产生刹车时间,即定时器 8 停止输出 PWM。当刹车输入引脚被拉高时,通道 1 和通道 2 将从有波形输入状态转换成无效电平状态。

嵌入式阿齐Archie 6742

智能小车避障功能的实现(cpp,ubuntu)

智能小车避障功能的实现(cpp,ubuntu)

weixin_62135607的博客 4376

安卓IPC机制之Binder详解

IPC(Inter-Process Communication,跨进程通信)是指两个进程之间数据交换的过程,因此我们首先必须了解什么是进程,什么是线程。

(* ̄︶ ̄) 3万+

姿态传感器/陀螺仪之SC7A20HTR是应用驱动程序设计

define SC7A20_CTRL1_PM_100HZ (0x5 << 4) // 正常模式,100Hz输出数据速率(ODR)// 用于存储6字节的原始数据(X_L, X_H, Y_L, Y_H, Z_L, Z_H)#define SC7A20_WHO_AM_I_VALUE 0x11 // 读取WHO_AM_I寄存器应该返回的值。// 但HAL_I2C_Mem_Read按顺序读,data[0]是X_L(低8位),data[1]是X_H(高8位)MX_I2C1_Init();

corlin6688的博客 765

Android中Binder IPC机制

Binder IPC机制,学不动也要学

永琪的博客 3938

【GameFramework框架内置模块】6、实体(Entity)

实体Entity就是一个实体的基本单元,类似于Unity的GameObject对象本体,然后这个本体上面附加其他各种各样组件,才能实现各种各样的功能。一般需要在游戏运行时动态加载的游戏对象,比如怪物、武器、子弹、特效,都需要给这个物体挂载一个实体Entity,这样的话就可以方便的对实例出来的对象进行管理。下面就来看一下如何使用吧。

优快云博客专家,Unity3D高级软件工程师,《Unity 3D从入门到实战》作者。 3137

NVIDIA Isaac GR00T N1.5 人形机器人强化学习入门教程(四)Lerobot、宇树 G1 等不同形态机器人微调教程

本笔记本是一份关于如何在新的数据集上对GR00T-N1预训练模型进行微调的教程。

2506_90492529的博客 1668

Android IPC 之Binder基础

前言 IPC 系列文章: 建议按顺序阅读。 Android IPC 之Service 还可以这么理解 Android IPC 之Binder基础 Android IPC 之Binder应用 Android IPC 之AIDL应用(上) Android IPC 之AIDL应用(下) Android IPC 之Messenger 原理及应用 Android IPC 之服务端回调 Android IPC 之获取服务(IBinder) 在平时的开发中,大部分时候都在编写单个App,每个App就是个进程。App之

1410

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Android IPC 之Binder应用

前言 IPC 系列文章: 建议按顺序阅读。 Android IPC 之Service 还可以这么理解 Android IPC 之Binder基础 Android IPC 之Binder应用 Android IPC 之AIDL应用(上) Android IPC 之AIDL应用(下) Android IPC 之Messenger 原理及应用 Android IPC 之服务端回调 Android IPC 之获取服务(IBinder) 上篇文章分析了Binder作为IPC中的一种在Android里发挥着重要的作

1541

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

Android IPC Binder

Binder原本是IPC工具,但是在Android中它的主要作用是支持RPC(Remote Procedure Call),使得当前进程调用另一个进程的函数就像调用自身的函数是一样轻松简单。Binder由Service Server(含有Android的服务)、Service Client(使用服务的客户端)、Context Manager(确定服务的位置)、以及Binder Dirver四部分组成。

fengjie_123的专栏 463

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

Android Binder IPC机制深度解析

本文分析了Android系统中AMS服务与App进程通过Binder IPC的通信机制。重点阐述了profileControl方法的调用链:AMS通过BpBinder代理将请求序列化发送至Binder驱动,驱动转发至目标App的Binder线程池,BnBinder实现类反序列化后调用本地方法。过程涉及参数序列化、线程切换和安全性校验,其架构类似于电话交换系统(AMS为拨号方,Binder驱动为交换机,App线程池为接听方)。关键源码涵盖IApplicationThread、Binder驱动和Activity

本博客聚焦游戏开发技巧、创业实战心得及大学热门课程干货。这里既有技术深度,也有思维广度,无论你是开发者、创业者还是高校学子,都能在这里找到适合自己的成长之路! 862

Android Binder IPC 机制

即进程间通信。Android 系统中的应用组件(如 Activity、Service)可能运行在不同的进程中,它们需要一种机制来安全高效地通信。Binder 就是 Android 为实现这一目标而设计的核心通信机制Binder 的核心思想:Client-Server 架构。一个进程作为Server提供服务,另一个进程作为Client调用服务。Binder 驱动(内核模块)作为“路由器”和“交通警察”,负责在进程间安全地传递消息为什么是 Binder?高性能。

w2064004678的博客 833

Android Binder IPC

android进程和linux进程一样,他们只运行在进程固有的虚拟地址空间中。一个4G的虚拟地址空间,3G是用户空间,1G是内核空间(通过内核设定可以修改)。用户代码和相关库分别运行在用户空间的代码区域,数据区域以及堆栈区域中,而内核空间中运行的代码则运行在内核空间的各个区域,并且进程具有各自独立的地址空间,单独运行。 一个具有独立地址空间的进程向另一个进程传递数据是通过共享的内核空间。从内核的

yhcelebrite的专栏 1136

Android IPC机制(二)Binder

在Android开发中,进程间通信(IPC)是一个重要的概念,而Binder则是Android系统中实现IPC的核心机制。本文将详细介绍Binder的工作原理、其在Android中的重要性以及与其他IPC机制的对比。

weixin_63357306的博客 1302

深度剖析Android Binder IPC机制

Binder是Android系统中的IPC机制,它允许不同进程之间进行高效、安全的通信。Binder基于客户端-

Android23333的博客 1117
上一篇: ARM汇编之栈
下一篇: ARM实战前的准备 :
Dr. 熊
博客等级 码龄10年 29粉丝 140原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值