Android进阶-Binder原理讲解

最新推荐文章于 2024-06-15 20:00:00 发布
最新推荐文章于 2024-06-15 20:00:00 发布
阅读量670 收藏 3
点赞数
分类专栏： 阅读笔记 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41994594/article/details/125553732
版权

0、Binder是什么？

1）机制：是一种进程间通信机制；
2）驱动：是一个虚拟物理设备驱动：
3）应用层：是一个能发起通信的Java类；service -> new stub（继承自Binder）

1、Binder有什么优势？

多进程的使用及优势：虚拟机分配给各个进程的运行内存是有限制的，LMK也会优先回收对系统资源的占用多的进程。
1）突破进程内存限制，如图库占用内存过多；
2）功能稳定性：独立的通信进程包保持长连接稳定性；
3）规避系统内存泄露：独立的WebView进程阻隔内存泄漏导致的问题；
4）隔离风险：对于不稳定的功能放入独立进程，避免导致主进程崩溃；
在这里插入图片描述
进程间的通信机制:共享内存、socket、管道、消息队列
特点：
1）性能：需要拷贝一次：
2）特点：基于C/S（客户端/服务端）架构：
3）安全性：为每个APP分配UID同时支持实名和匿名，而共享内存依赖于上层协议
uid可以找到对应的service、防止恶意软件入侵手机。再service注册时 将uid传给binder
实名：注册的；匿名：

2、Binder是怎么做到一次拷贝（系统调用）的？

传统的ipc通信，线程之间的内存是可以共享的 但进程是内存隔离的
进程之间只能通过内核控件调用
在这里插入图片描述

内存映射-》
虚拟内存-》安卓开发所说的内存-》指针-》虚拟地址（一个虚拟的地址指向）
物理内存-》
在这里插入图片描述

所有进程的内核空间是共享一个物理内存的（地球仪和地球的关系）
用户空间和内核控件通过系统调用，而Binder相当于给用户空间和内核控件提供了一个共享区域进行内存映射 因此无需两次copy
Binder又google工程师处理数据 无需担心数据死锁

3、MMAP的原理讲解

在这里插入图片描述

memory mapping
把虚拟内存和指定的物理内存进行绑定，开辟一块空间 指向该虚拟内存 将内存指向指针
虚拟内存-》物理内存（Binder驱动（文件）提供）

4、Binder机制是如何跨进程的

在这里插入图片描述
在这里插入图片描述
startActivity会发生几次通信？==bind Service会发生几次跨进程通信？进行6次跨进程通信。
init pid=1 -> init.rc-》zygote-》fork system service
serviceManager（服务器表）-》见通信机制
在这里插入图片描述

5、描述AIDL生产的java类细节

public interface IBookManager extends android.os.IInterface {
    /**
     * Local-side IPC implementation stub class.
     */
    public static abstract class Stub extends android.os.Binder implements com.example.xushuzhan.aidltest.IBookManager {
        private static final java.lang.String DESCRIPTOR = "com.example.xushuzhan.aidltest.IBookManager";

        /**
         * Construct the stub at attach it to the interface.
         */
        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

        /**
         * Cast an IBinder object into an com.example.xushuzhan.aidltest.IBookManager interface,
         * generating a proxy if needed.
         */
        public static com.example.xushuzhan.aidltest.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.xushuzhan.aidltest.IBookManager))) {
                return ((com.example.xushuzhan.aidltest.IBookManager) iin);
            }
            return new com.example.xushuzhan.aidltest.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 {
            switch (code) {
                case INTERFACE_TRANSACTION: {
                    reply.writeString(DESCRIPTOR);
                    return true;
                }
                case TRANSACTION_basicTypes: {
                    data.enforceInterface(DESCRIPTOR);
                    int _arg0;
                    _arg0 = data.readInt();
                    long _arg1;
                    _arg1 = data.readLong();
                    boolean _arg2;
                    _arg2 = (0 != data.readInt());
                    float _arg3;
                    _arg3 = data.readFloat();
                    double _arg4;
                    _arg4 = data.readDouble();
                    java.lang.String _arg5;
                    _arg5 = data.readString();
                    this.basicTypes(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5);
                    reply.writeNoException();
                    return true;
                }
                case TRANSACTION_getBook: {
                    data.enforceInterface(DESCRIPTOR);
                    com.example.xushuzhan.aidltest.BookBean _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;
                }
                case TRANSACTION_addBook: {
                    data.enforceInterface(DESCRIPTOR);
                    com.example.xushuzhan.aidltest.BookBean _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.example.xushuzhan.aidltest.BookBean.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    this.addBook(_arg0);
                    reply.writeNoException();
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        private static class Proxy implements com.example.xushuzhan.aidltest.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 void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, java.lang.String aString) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    _data.writeInt(anInt);
                    _data.writeLong(aLong);
                    _data.writeInt(((aBoolean) ? (1) : (0)));
                    _data.writeFloat(aFloat);
                    _data.writeDouble(aDouble);
                    _data.writeString(aString);
                    mRemote.transact(Stub.TRANSACTION_basicTypes, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }

            @Override
            public com.example.xushuzhan.aidltest.BookBean getBook() throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                com.example.xushuzhan.aidltest.BookBean _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    mRemote.transact(Stub.TRANSACTION_getBook, _data, _reply, 0);
                    _reply.readException();
                    if ((0 != _reply.readInt())) {
                        _result = com.example.xushuzhan.aidltest.BookBean.CREATOR.createFromParcel(_reply);
                    } else {
                        _result = null;
                    }
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }

            @Override
            public void addBook(com.example.xushuzhan.aidltest.BookBean 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_addBook, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }

        static final int TRANSACTION_basicTypes = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
        static final int TRANSACTION_getBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
        static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
    }

    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, java.lang.String aString) throws android.os.RemoteException;

    //定义返回书本的方法
    public com.example.xushuzhan.aidltest.BookBean getBook() throws android.os.RemoteException;

    //定义添加书本的方法，这里的 in 代表数据的流向是：客户端->服务端，服务端对数据的任何修改都不会影响到客户端
    public void addBook(com.example.xushuzhan.aidltest.BookBean book) throws android.os.RemoteException;
}

**onTransact(int code, Parcel data, Parcel reply, int flags)：**这就是一个比较核心的方法了，它主要是用来执行远程调用的目标方法，执行完后把返回值写入reply中。这个方法是运行在服务端的Binder线程池中，客户端发起请求的时候，会通过系统底层封装后交给此方法来处理，如果返回false，那么客户端将请求失败（调用不到所请求的方法）。参数如下：
**code：**即AIDL接口中方法的唯一标识，通过它可以确定调用的是那个方法。
**data：**客户端远程调用方法的时候传过来的参数的值被封装进了这个data，需要就可以取出。
**reply：**当前方法的返回值会被封装进reply。
**flags：**只有0和1（FLAG_ONEWAY）两种取值，取0表示同步操作（默认），取1表示客户端单向操作，无需等待服务端响应。

6、四大组件底层通信机制

参考aidl和binder通信原理

7、为什么Intent不能传递大数据？==binder传递数据限制

同步传输最大限制1M-8k约等于512k 异步要除以2。binder mmap底层异步有底层的限制
在这里插入图片描述在这里插入图片描述

剩余可了解：binder的数据结构(4个红黑树)线程池的设计

guoguooooooooo
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android_Binder原理分析
黎程雨的博客
07-03 454
Binder是什么? Binder可以实现进程与进程之间的通信(IPC), Binder是Android底层系统的一个特色了,它很好地解决了进程间通讯的问题。 可能很多小伙伴对Binder感觉有点儿陌生,但是Binder在Android系统中无处不在,比如: 媒体的播放 音视频捕获 传感器使用 startActivity()/startService() 等... Binder是Android独有的跨线程通讯机制,它的运行机制和现实中的一个例子很像,我们来看一张图 ...
5.6.7Binder系统_驱动情景分析_transaction_stack机制_REPLY
qq_34738528的博客
03-12 387
回顾 通过前面的学习我们知道，binder通信涉及搭配两个进程，A,B： A发送一个BC_TRANSACTION消息给驱动，驱动把其转化为BR_TRANSACTIONB转发给B。 B接收到一个类型为BR_TRANSACTIONB的数据，然后发送一个BC_REPLY的消息给驱动，驱动把其转化为BR_REPLY，然后回复给A进程。 简单概述 在前面的分析中，我们没有详细的分析，驱动...
一次Binder通信最大可以传输多大的数据？
最新发布
lightingstar的博客
06-15 1644
在前面的文章中，我通过匿名共享内存的方式解决Binder通信是无法传递大数据的问题，一次Binder通信最大可以传输是1MB-8KB（PS：8k是两个pagesize，一个pagesize是申请物理内存的最小单元）
Android Binder机制原理
alankin的博客
05-22 6634
Android Binder机制原理 说起Binder，其实在我们开发中总是没有感觉到它的存在，但是往往在很多地方都间接的在使用它，比如我们再startAcivity的时候，必定要去调用ActivityManagerService，因为我们都知道Activity并不是我们直接new出来的，而是通过这个service创建出来的，然而这个service是处于另外的进程，我们就必须要通过binder获...
Android Binder原理
xianKOG的博客
12-12 716
IPC机制：进程间通信（Inter Process communication），指两个进程之间进行数据交换 进程知识点 进程空间的分配 一个进程空间可以分为用户空间和内核空间（Kernel），即把进程内 用户 和 内核隔离开来 二者的区别： 用户空间的数据在进程之间是不可共享的，所以 用户空间 = 不可共享空间 内核空间的数据在进程之间是共享 的，所以用户空间 = 可共享空间 在进程之间...
Android Binder机制 原理
ch853199769的博客
05-11 1111
Linux进程空间 内核模块/驱动 Binder 架构 Binder 机制 Binder 进程与线程 ServiceManager ServiceManager 启动 ServiceManager 注册服务 ServiceManager 获取服务 进行一次完整通讯 Linux进程空间 一个进程空间分为 用户空间 & 内核空间（Kernel），即把进程内 用户 &a...
《Android Binder-原理概述》
墨客联盟
12-18 204
概述 Android系统中，每个应用程序是由Android的 Activity, Service, Broadcast, ContentProvider 这四大组件中的一个或者多个组合而成，四大组件涉及进程间的通信底层都是依赖于 Binder IPC 机制。例如当进程 A 中的 Activity 要向进程 B 中的 Service 通信，这便需要依赖于 Binder IP...
Android进阶书籍
08-24
《Android进阶书籍》是专为那些希望提升Android应用开发技能的开发者准备的资源集合，包含两本重量级的电子书：《Android开发艺术探索》和《顾浩鑫-Android高级进阶(带书签高清版)》。这两本书籍深入浅出地探讨了...
android--service实例
07-29
本教程将深入探讨“android--service实例”，讲解如何创建、启动、绑定以及管理Service。 首先，我们来理解Service的基本概念。在Android应用开发中，Service主要用于处理那些不需要用户界面但需要后台运行的任务，...
Android-application-development.zip_android开发_Java_
08-11
本教程的“Java”部分将深入讲解Java语言的基础和进阶特性，包括类、对象、封装、继承、多态、异常处理、集合框架、IO流、网络编程等。对于Android开发，尤其需要注意Java与Android框架的结合，如Android的...
精通ANDROID实例开发-高清.7z
06-24
《精通ANDROID实例开发》这本书是Android开发者进阶的宝贵资源，尤其适合已经掌握了基础的Android编程知识并希望深化理解和实践应用的程序员。本书的核心在于通过丰富的实例，帮助读者深入理解Android平台上的应用...
图解android Binder 实现机制
05-05
通过图解的方式，将Android Binder通信的根本原理呈现出来。
Android的 Binder 原理剖析
Hfengxiang的博客
05-29 418
一. Binder 概述 简单介绍下什么是 Binder。Binder 是一种进程间通信机制，基于开源的 OpenBinder 实现；OpenBinder 起初由 Be Inc. 开发，后由 Plam Inc. 接手。从字面上来解释 Binder 有胶水、粘合剂的意思，顾名思义就是粘和不同的进程，使之实现通信。对于 Binder 更全面的定义，等我们介绍完 Binder 通信原理后再做详细说明。 1.1 为什么必须理解 Binder ？ 作为 Android 工程师的你，是不是常常会有这样的疑问：..
Android Binder原理初探
一个小菜鸟的成长之路的专栏
01-18 305
1、Binder的通信原理 动态内核可加载模块&&内存映射 在Android Binder开卷中所说的IPC通信模型中所描述的，跨进程通信需要内核空间做支持。传统的IPC机制如管道，Socket都是内核的一部分，因此通过内核支持来实现进程间通信自然没有问题。但是Binder并不是Liunx系统内核的一部分。Binder机制得益于Liunx的动态内核可加载模块(Loadable ...
Android binder 原理及实现机制<一>
desler的专栏
08-23 1721
​0，从android native service 说起 我们先来看一个简单的 native service 例子: // 定义能力接口 class IBuddy: public IInterface { public: enum { BUDDY_GET_PID = IBinder::FIRST_CALL_TRANSACTION, }; virtual
半路Android，开发5年才8K+?Android还能打吗？
m0_46962786的博客
11-06 275
25岁，我转行程序员 我，普通家庭，大专学历，学的是工商管理。出来后在一个酒店实习，每个月按时上班下班，普普通通，拿着两千多一点的基本工资，只能满足自己的基本日常开支，我感觉自己继续这样下去根本没有出路。 就这样干了三年，薪资也不过三千多。后面听说，干程序员这行赚钱，刚好在网上看见了一个Android培训班的广告，于是用自己攒的一点钱，一狠心，报了名。 当时自己身上也没有多少钱，也不好意思找家里，就退了合租的房子，搬进了公司职工宿舍，一边继续工作，一边下班学习。 入行 因为我的基础比较差，花费的时间比较多。
Android-全面理解Binder原理
深海流浪汉
02-07 1616
一文打通你对Binder通信机制所有疑惑： - 如何理解Binder通信中的 binder实体、handle句柄？ - Binder驱动如何维护binder实体和handle的映射？ - Binder能够传递多大的数据？ - Binder的“一次拷贝”是如何实现的？ - client端如何接收到数据？ - servicemanager的初始化和app、服务不同？ - 进程隔离、IPC通信的介绍与思考。 - 为什么选择 Binder？
Android进阶宝典：框架UI深度解析
深入理解Android卷3是一本由邓平凡大神编著的Android进阶指南，作为国内"深入理解Android"系列的最后一卷，它着重于深入剖析Android Framework中与用户界面(UI)密切相关的模块。本书涵盖了多个核心主题，如Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值