Android Java Parcel与Native Parcel的关系

这篇文章通过Java Binder Parcel的例子，分析Java Parcel与Native Parcel的关系

Java Binder Parcel 示例代码

@Override
public int add(int first, int second) throws android.os.RemoteException {
    android.os.Parcel _data = android.os.Parcel.obtain();
    android.os.Parcel _reply = android.os.Parcel.obtain();
    int _result;
    try {
        _data.writeInterfaceToken(DESCRIPTOR);
        _data.writeInt(first);
        _data.writeInt(second);
        boolean _status = mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);
        if (!_status && getDefaultImpl() != null) {
            return getDefaultImpl().add(first, second);
        }
        _reply.readException();
        _result = _reply.readInt();
    } finally {
        _reply.recycle();
        _data.recycle();
    }
    return _result;
}

从代码可以看到Parcel相关的操作可以分为三部分，分别是：

1. Parcel的创建

android.os.Parcel _data = android.os.Parcel.obtain();

2. 通过Parcel存储和读取数据
   存储：

_data.writeInt(first);

读取：

_result = _reply.readInt();

3. 通过Parcel释放相关数据

_reply.recycle();
_data.recycle();

以下就三部分进行分析。

Parcel的创建

public static Parcel obtain() {
    final Parcel[] pool = sOwnedPool;
    synchronized (pool) {
        Parcel p;
        for (int i=0; i<POOL_SIZE; i++) {
            p = pool[i]; //1
            if (p != null) {
                pool[i] = null;
                if (DEBUG_RECYCLE) {
                    p.mStack = new RuntimeException();
                }
                p.mReadWriteHelper = ReadWriteHelper.DEFAULT;
                return p;
            }
        }
    }
    return new Parcel(0); //2
}

private Parcel(long nativePtr) {
    if (DEBUG_RECYCLE) {
        mStack = new RuntimeException();
    }
    //Log.i(TAG, "Initializing obj=0x" + Integer.toHexString(obj), mStack);
    init(nativePtr); //3
}

private void init(long nativePtr) {
    if (nativePtr != 0) {
        mNativePtr = nativePtr;
        mOwnsNativeParcelObject = false;
    } else {
        mNativePtr = nativeCreate(); //4
        mOwnsNativeParcelObject = true;
    }
}

private static native long nativeCreate();

private long mNativePtr;
private static final int POOL_SIZE = 6;
private static final Parcel[] sOwnedPool = new Parcel[POOL_SIZE];

从以上代码可知，obtain函数从全局变量sOwnedPool数组中取Parcel对象（见代码1），如果取不到，就创建一个（见代码2）。Parcel创建会执行构造函数，在构造函数中又会调用init函数（见代码3）。init函数此时参数为0,又会执行nativeCreate函数（见代码4）。nativeCreate函数是一个native函数，看下实现：

base/core/jni/android_os_Parcel.cpp

static const JNINativeMethod gParcelMethods[] = {
    ...
    {"nativeCreate",              "()J", (void*)android_os_Parcel_create},//5
    ...
};

static jlong android_os_Parcel_create(JNIEnv* env, jclass clazz)
{
    Parcel* parcel = new Parcel(); //6
    return reinterpret_cast<jlong>(parcel); //7
}

从以上代码可知，Java层的nativeCreate native函数在Jni层的实现是android_os_Parcel_create函数（见代码5）android_os_Parcel_create函数做了两件事情。第一件事情就是创建了一个native层的Parcel对象（见代码6）。第二件事情就是把这个Parcel对象的指针转化为long类型的数据并返回为Java层（见代码7）。
让我们再回到代码4处，nativeCreate函数的返回值会赋值给成员变量mNativePtr。到此，我们就分析完了Parcel.obtain。
总结如下：

1. 从Parcel Pool中取Parcel对象，没有就创建一个Java Parcel对象。
2. Java Parcel对象会通过Jni创建一个Native Parcel对象。
3. 将Native Parcel对象的指针转化为long类型的数据赋值给Java层的mNativePtr成员变量。

通过Parcel存储和读取数据

public final void writeInt(int val) {
    nativeWriteInt(mNativePtr, val);
}

public final int readInt() {
    return nativeReadInt(mNativePtr);
}

@CriticalNative
private static native int nativeReadInt(long nativePtr);

@FastNative
private static native void nativeWriteInt(long nativePtr, int val);

从以上代码可知：Parcel存储和读取数据调用的都是native方法，参数中都含有long类型的mNativePtr成员变量。我们看下jni层的函数实现：

base/core/jni/android_os_Parcel.cpp

static const JNINativeMethod gParcelMethods[] = {
    ...
    // @FastNative
    {"nativeWriteInt",            "(JI)V", (void*)android_os_Parcel_writeInt},
    ...
    // @CriticalNative
    {"nativeReadInt",             "(J)I", (void*)android_os_Parcel_readInt},
    ...
};

static void android_os_Parcel_writeInt(JNIEnv* env, jclass clazz, jlong nativePtr, jint val) {
    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
    if (parcel != NULL) {
        const status_t err = parcel->writeInt32(val);
        if (err != NO_ERROR) {
            signalExceptionForError(env, clazz, err);
        }
    }
}

static jint android_os_Parcel_readInt(jlong nativePtr)
{
    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
    if (parcel != NULL) {
        return parcel->readInt32();
    }
    return 0;
}

从以上代码可知：不管是nativeReadInt还是nativeWriteInt，其在jni层都是通过把上层的mNativePtr变量转化为Parcel指针来进行write或read操作。

通过Parcel释放相关数据

public final void recycle() {
    if (DEBUG_RECYCLE) mStack = null;
    freeBuffer();//8

    final Parcel[] pool;
    if (mOwnsNativeParcelObject) {
        pool = sOwnedPool;
    } else {
        mNativePtr = 0;
        pool = sHolderPool;
    }

    synchronized (pool) {
        for (int i=0; i<POOL_SIZE; i++) {
            if (pool[i] == null) {
                pool[i] = this;//9
                return;
            }
        }
    }
}

private void freeBuffer() {
    if (mOwnsNativeParcelObject) {
        updateNativeSize(nativeFreeBuffer(mNativePtr));
    }
    mReadWriteHelper = ReadWriteHelper.DEFAULT;
}

private static native long nativeFreeBuffer(long nativePtr);

private static final int POOL_SIZE = 6;
private static final Parcel[] sOwnedPool = new Parcel[POOL_SIZE];

从以上代码可知，recycle主要做了两件事情，第一件事情就是执行freeBuffer函数（见代码8），第二件事情就是把Java Parcel对象存储于Parcel Pool中，以便Parcel的复用，减少内存性能开销。第二件事情在Java层就可以说清了，现在我们看下第一件事情：freeBuffer函数的核心操作是调用了nativeFreeBuffer，它是一个native函数，接收的参数也是long类型的成员变量mNativePtr。

base/core/jni/android_os_Parcel.cpp

static const JNINativeMethod gParcelMethods[] = {
    ...
    {"nativeFreeBuffer",          "(J)J", (void*)android_os_Parcel_freeBuffer},
    ...
};

static jlong android_os_Parcel_freeBuffer(JNIEnv* env, jclass clazz, jlong nativePtr)
{
    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
    if (parcel != NULL) {
        parcel->freeData();
        return parcel->getOpenAshmemSize();
    }
    return 0;
}

从以上代码可知，nativeFreeBuffer函数在jni层通过把上层的mNativePtr变量转化为Parcel指针来进行freeData操作。

总结：

从以上三部分分析可见：

1. Java Parcel在创建的时候会创建Native Parcel，并把Native Parcel对象的指针转化为long类型保存到成员变量mNativePtr中。
2. Java Parcel的write和read以及recycle操作都是借助Native Parcel来执行。

最后

如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。

如果你没有方向，这里给大家分享一套由阿里高级架构师编写的《Android八大模块进阶笔记》，帮大家将杂乱、零散、碎片化的知识进行体系化的整理，让大家系统而高效地掌握Android开发的各个知识点。

相对于我们平时看的碎片化内容，这份笔记的知识点更系统化，更容易理解和记忆，是严格按照知识体系编排的。

全套视频资料：

一、面试合集

二、源码解析合集

三、开源框架合集

欢迎大家一键三连支持，若需要文中资料，直接扫描文末CSDN官方认证微信卡片免费领取↓↓↓

PS:群里还设有ChatGPT机器人，可以解答大家在工作上或者是技术上的问题