Android智能指针 ⭐⭐⭐

// RefBase 构造函数（简化版）
// 在 RefBase 对象构造时，同步创建 weakref_impl
RefBase::RefBase()
    : mRefs(new weakref_impl(this))  // 在堆上分配独立的引用计数管理器
{
    // mRefs 指向新创建的 weakref_impl
    // weakref_impl 内部持有回指 RefBase 的指针 mBase
}

class RefBase::weakref_impl : public RefBase::weakref_type {
public:
    std::atomic<int32_t> mStrong;  // 强引用计数，原子类型
    std::atomic<int32_t> mWeak;    // 弱引用计数，原子类型
    RefBase* const       mBase;    // 回指被管理的 RefBase 对象（const 指针，不可变）
    std::atomic<int32_t> mFlags;   // 生命周期控制标志
 
    // 构造函数
    explicit weakref_impl(RefBase* base)
        : mStrong(INITIAL_STRONG_VALUE)  // 强引用初始化为哨兵值 0x10000000
        , mWeak(0)                        // 弱引用初始化为 0
        , mBase(base)                     // 记录所管理的对象
        , mFlags(OBJECT_LIFETIME_STRONG)  // 默认：强引用控制生命周期
    {
    }
};

void RefBase::incStrong(const void* id) const
{
    weakref_impl* const refs = mRefs;        // 获取引用计数管理器
 
    refs->incWeak(id);                        // ① 先增加弱引用计数（每个强引用也占一份弱引用）
 
    refs->addStrongRef(id);                   // ② Debug 用：记录强引用来源（Release 版为空操作）
 
    // ③ 原子地将 mStrong 加 1，并返回旧值
    const int32_t c = refs->mStrong.fetch_add(1, std::memory_order_relaxed);
 
    // ④ 如果旧值不是哨兵值，说明不是第一次被强引用，直接返回
    if (c != INITIAL_STRONG_VALUE) {
        return;
    }
 
    // ⑤ 第一次被强引用：把哨兵值减掉，使 mStrong 变为真实计数值
    // 此时 mStrong = INITIAL_STRONG_VALUE + 1，减去哨兵后 = 1
    int32_t old __unused = refs->mStrong.fetch_sub(INITIAL_STRONG_VALUE,
                                                     std::memory_order_relaxed);
 
    // ⑥ 通知子类：对象第一次被强引用（生命周期回调）
    refs->mBase->onFirstRef();
}

void RefBase::decStrong(const void* id) const
{
    weakref_impl* const refs = mRefs;        // 获取引用计数管理器
 
    refs->removeStrongRef(id);               // ① Debug 用：移除强引用记录
 
    // ② 原子地将 mStrong 减 1，并返回旧值
    const int32_t c = refs->mStrong.fetch_sub(1, std::memory_order_release);
 
    // ③ 如果旧值为 1，说明减完后变成 0 —— 这是最后一个强引用
    if (c == 1) {
        // 内存屏障：确保所有之前的写操作在析构前可见
        std::atomic_thread_fence(std::memory_order_acquire);
 
        // ④ 通知子类：最后一个强引用即将消失
        refs->mBase->onLastStrongRef(id);
 
        // ⑤ 根据生命周期标志决定是否 delete 对象
        int32_t flags = refs->mFlags.load(std::memory_order_relaxed);
        if ((flags & OBJECT_LIFETIME_MASK) == OBJECT_LIFETIME_STRONG) {
            // 默认模式：强引用控制生命周期，直接 delete 对象本体
            delete this;
        }
        // 如果是 OBJECT_LIFETIME_WEAK 模式，则不在此 delete
        // 对象会延迟到弱引用也归零时才销毁
    }
 
    // ⑥ 最后减少弱引用计数（对应 incStrong 中的 incWeak）
    refs->decWeak(id);
}

// 定义一个继承 RefBase 的类
class Camera : public RefBase {
public:
    Camera()  { /* 构造 */ }     // 此时 mStrong=0x10000000, mWeak=0
    ~Camera() { /* 析构 */ }
 
    void onFirstRef() override {
        // 第一次被 sp 持有时回调
        ALOGD("Camera onFirstRef");
    }
 
    void onLastStrongRef(const void* id) override {
        // 最后一个 sp 释放时回调
        ALOGD("Camera onLastStrongRef");
    }
};
 
void example() {
    // --- 阶段 1：创建对象 ---
    Camera* raw = new Camera();
    // mStrong = INITIAL_STRONG_VALUE (0x10000000)
    // mWeak   = 0
 
    {
        // --- 阶段 2：第一个 sp 持有 ---
        sp<Camera> sp1(raw);
        // incStrong: mWeak 0→1, mStrong 0x10000000→0x10000001
        //            检测到哨兵值，mStrong -= 0x10000000 → mStrong=1
        //            调用 onFirstRef()
        // 结果: mStrong=1, mWeak=1
 
        {
            // --- 阶段 3：第二个 sp 持有 ---
            sp<Camera> sp2(sp1);
            // incStrong: mWeak 1→2, mStrong 1→2
            // 结果: mStrong=2, mWeak=2
 
            {
                // --- 阶段 4：一个 wp 持有 ---
                wp<Camera> wp1(sp1);
                // incWeak: mWeak 2→3
                // 结果: mStrong=2, mWeak=3
 
            }   // --- 阶段 5：wp1 析构 ---
                // decWeak: mWeak 3→2
                // 结果: mStrong=2, mWeak=2
 
        }   // --- 阶段 6：sp2 析构 ---
            // decStrong: mStrong 2→1 (旧值2, 不是1, 不销毁)
            //            decWeak: mWeak 2→1
            // 结果: mStrong=1, mWeak=1
 
    }   // --- 阶段 7：sp1 析构 ---
        // decStrong: mStrong 1→0 (旧值1, 触发销毁!)
        //            调用 onLastStrongRef()
        //            delete this → Camera 析构函数执行
        //            decWeak: mWeak 1→0 → weakref_impl 也被 delete
}

class RefBase::weakref_type {
public:
    RefBase* refBase() const;               // 获取所管理的 RefBase 对象指针
 
    void incWeak(const void* id);           // 弱引用计数 +1
    void decWeak(const void* id);           // 弱引用计数 -1
 
    bool attemptIncStrong(const void* id);  // 尝试将弱引用提升为强引用（核心!）
 
    bool attemptIncWeak(const void* id);    // 尝试增加弱引用（用于特殊场景）
 
    int32_t getWeakCount() const;           // 获取当前弱引用计数（仅调试用）
};

void RefBase::weakref_type::incWeak(const void* id)
{
    weakref_impl* const impl = static_cast<weakref_impl*>(this);  // 向下转型到实现类
    impl->addWeakRef(id);                                          // Debug 记录
    const int32_t c __unused = impl->mWeak.fetch_add(1,           // 原子 +1
                                        std::memory_order_relaxed);
}

void RefBase::weakref_type::decWeak(const void* id)
{
    weakref_impl* const impl = static_cast<weakref_impl*>(this);  // 向下转型
    impl->removeWeakRef(id);                                       // Debug 记录
 
    // 原子 -1 并返回旧值
    const int32_t c = impl->mWeak.fetch_sub(1, std::memory_order_release);
 
    if (c != 1) return;  // 旧值不为 1，说明减完后不为 0，还有其他弱引用
 
    // --- 弱引用计数归零 ---
    atomic_thread_fence(std::memory_order_acquire);  // 获取屏障
 
    int32_t flags = impl->mFlags.load(std::memory_order_relaxed);
 
    if ((flags & OBJECT_LIFETIME_MASK) == OBJECT_LIFETIME_STRONG) {
        // 强引用控制模式（默认）：
        // 对象本体已在 decStrong 中被 delete
        // 现在只需 delete weakref_impl 自身
        if (impl->mStrong.load(std::memory_order_relaxed)
                == INITIAL_STRONG_VALUE) {
            // 特殊情况：对象从未被强引用过（只有 wp 指向它）
            // 需要在这里 delete 对象本体
            delete impl->mBase;
        } else {
            // 正常情况：对象本体已被删除，清理 impl
            delete impl;
        }
    } else {
        // OBJECT_LIFETIME_WEAK 模式：
        // 弱引用也控制生命周期，现在弱引用归零，才 delete 对象
        impl->mBase->onLastWeakRef(id);
        delete impl->mBase;  // 对象析构函数中会 delete impl
    }
}

bool RefBase::weakref_type::attemptIncStrong(const void* id)
{
    incWeak(id);  // ① 先增加一份弱引用保护（防止 impl 在操作过程中被销毁）
 
    weakref_impl* const impl = static_cast<weakref_impl*>(this);
 
    // ② 读取当前强引用计数
    int32_t curCount = impl->mStrong.load(std::memory_order_relaxed);
 
    // ③ 如果当前强引用计数 > 0 且不是哨兵值，说明对象仍存活
    //    用 CAS 循环尝试 +1
    while (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {
        if (impl->mStrong.compare_exchange_weak(curCount, curCount + 1,
                std::memory_order_relaxed)) {
            break;  // CAS 成功，强引用 +1 完成
        }
        // CAS 失败（其他线程修改了 mStrong），curCount 已被更新，重试
    }
 
    if (curCount <= 0 || curCount == INITIAL_STRONG_VALUE) {
        // ④ 强引用为 0 或从未被强引用过 —— 需要更复杂的判断
        // 检查生命周期标志和 onIncStrongAttempted 回调来决定是否允许提升
        // ... （此处省略复杂的边界处理逻辑）
 
        // 如果最终判定无法提升：
        // decWeak(id);  // 回滚 ① 中增加的弱引用
        // return false;
    }
 
    // ⑤ 提升成功
    impl->addStrongRef(id);  // Debug 记录
 
    // ⑥ 如果原来是哨兵值（首次强引用），执行同 incStrong 相同的哨兵清除 + onFirstRef
    if (curCount == INITIAL_STRONG_VALUE) {
        impl->mStrong.fetch_sub(INITIAL_STRONG_VALUE);
    }
 
    return true;
}

template <typename T>
class wp {
private:
    T*                  m_ptr;   // 原始对象指针（可能悬空，仅用于 promote 成功后返回）
    weakref_type*       m_refs;  // 弱引用管理器（独立于对象存活）
 
public:
    // 构造：从 sp 创建 wp
    wp(const sp<T>& other)
        : m_ptr(other.get())                         // 保存原始指针
    {
        if (m_ptr) {
            m_refs = m_ptr->createWeak(this);        // 获取 weakref_type* 并 incWeak
        }
    }
 
    // 析构
    ~wp() {
        if (m_ptr) {
            m_refs->decWeak(this);                   // 减少弱引用计数
        }
    }
 
    // 提升为强指针
    sp<T> promote() const {
        sp<T> result;
        if (m_ptr && m_refs->attemptIncStrong(&result)) {
            result.set_pointer(m_ptr);               // 提升成功，设置指针
        }
        return result;                               // 提升失败返回空 sp
    }
};

// 内存示意图（对象已被强引用释放后的状态）
//
// Stack                     Heap
// ┌─────────────┐          ┌───────────────────┐
// │ wp<Camera>  │          │  weakref_impl      │
// │  m_ptr ───────────X    │  mStrong = 0       │ (对象已死)
// │  m_refs ──────────────>│  mWeak   = 1       │ (wp 还持有)
// └─────────────┘          │  mBase   = 0xDEAD  │ (已失效)
//                          └───────────────────┘
//                          Camera 对象已被 delete，内存已回收

#include <utils/RefBase.h>       // RefBase 基类定义
#include <utils/StrongPointer.h> // sp<T> 模板定义
 
// 定义一个继承 RefBase 的业务类
class MyService : public RefBase {
public:
    MyService() {
        // 构造函数：RefBase 内部的强引用计数初始化为 INITIAL_STRONG_VALUE
        ALOGD("MyService created");
    }
 
    virtual ~MyService() {
        // 析构函数：当强引用计数归零时被调用
        ALOGD("MyService destroyed");
    }
 
    void doWork() {
        ALOGD("MyService is doing work...");
    }
};
 
void demonstrateBasicUsage() {
    // ====== 方式1：直接构造 ======
    // new 出对象后立即交给 sp 托管，强引用计数 → 1
    sp<MyService> svc = new MyService();
 
    // ====== 方式2：拷贝构造 ======
    // 拷贝 sp 会使强引用计数 +1 → 变为 2
    sp<MyService> svc2 = svc;
 
    // ====== 方式3：移动构造 (C++11) ======
    // 转移所有权，不改变引用计数（源 sp 变为 nullptr）
    sp<MyService> svc3 = std::move(svc);
    // 此时 svc.get() == nullptr，svc3 持有对象，强引用计数仍为 2
 
    // ====== 方式4：从裸指针赋值 ======
    MyService* raw = new MyService();   // 新对象，强引用计数 = INITIAL_STRONG_VALUE
    sp<MyService> svc4;                 // 默认构造，内部指针为 nullptr
    svc4 = raw;                         // 赋值操作触发 incStrong，强引用计数 → 1
 
    // ====== 使用：与裸指针语法完全一致 ======
    svc3->doWork();                     // operator-> 访问成员
    (*svc3).doWork();                   // operator* 解引用
    MyService* p = svc3.get();          // get() 获取裸指针（不增加引用计数）
 
    // 函数结束时，svc4, svc3, svc2 按逆序析构
    // 每次析构 decStrong → 引用计数 -1
    // 最后一个 sp 析构时计数归零 → delete 对象
}

// ====== 传参方式 ======
 
// 方式A：const 引用传递（推荐：只读场景，零拷贝，无引用计数开销）
void readService(const sp<MyService>& svc) {
    svc->doWork();   // 可以调用对象方法
    // 不会增减引用计数，性能最优
}
 
// 方式B：值传递（需要延长生命周期时使用，拷贝触发 incStrong）
void holdService(sp<MyService> svc) {
    // 进入函数时引用计数 +1
    // 可以安全地将 svc 存储到成员变量中
    mCachedService = svc;     // 再次拷贝 → 引用计数 +1
    // 函数退出 → 局部 svc 析构 → 引用计数 -1
}
 
// 方式C：值返回（利用 RVO/NRVO 优化，通常零开销）
sp<MyService> createService() {
    sp<MyService> svc = new MyService();  // 强引用计数 → 1
    return svc;  // 编译器通常执行 NRVO（Named Return Value Optimization）
                 // 直接在调用方的栈帧上构造，不产生额外的 inc/dec
}

// ICameraService.h（AIDL 自动生成的接口）
class ICameraService : public IInterface {
public:
    // 返回 sp 包裹的 Camera 设备代理
    virtual sp<ICameraDeviceUser> connectDevice(
        const String16& cameraId) = 0;       // 纯虚函数
};
 
// CameraService.cpp（服务端实现）
sp<ICameraDeviceUser> CameraService::connectDevice(
    const String16& cameraId) {
 
    // 创建设备客户端，sp 自动管理生命周期
    sp<CameraDeviceClient> client = new CameraDeviceClient(/*...*/);
 
    // 初始化，内部可能继续创建更多 sp 持有的子对象
    status_t err = client->initialize(mCameraProviderManager);
 
    if (err != OK) {
        // 如果初始化失败，函数结束时 client（sp）自动析构
        // 强引用计数归零 → CameraDeviceClient 被 delete
        return nullptr;   // 返回空 sp
    }
 
    // 返回 sp：调用方获得所有权，强引用计数不变（RVO优化）
    return client;
}

// frameworks/rs/cpp/util/StrongPointer.h（简化版）
template <typename T>
class sp {
public:
    // ---------- 构造 ----------
    sp() : m_ptr(nullptr) {}                // 默认构造：空指针
 
    sp(T* other) : m_ptr(other) {           // 裸指针构造
        if (m_ptr) {
            m_ptr->incStrong(this);         // 核心：调用 RefBase::incStrong
                                            // 参数 this 用于 debug 追踪（标识谁持有引用）
        }
    }
 
    sp(const sp<T>& other) : m_ptr(other.m_ptr) {  // 拷贝构造
        if (m_ptr) {
            m_ptr->incStrong(this);         // 强引用计数 +1
        }
    }
 
    sp(sp<T>&& other) noexcept              // 移动构造（C++11）
        : m_ptr(other.m_ptr) {
        other.m_ptr = nullptr;              // 转移所有权，无需操作引用计数
    }
 
    // ---------- 析构 ----------
    ~sp() {
        if (m_ptr) {
            m_ptr->decStrong(this);         // 核心：调用 RefBase::decStrong
                                            // 如果引用计数归零 → delete 对象
        }
    }
 
    // ---------- 赋值 ----------
    sp& operator=(T* other) {               // 裸指针赋值
        T* oldPtr = m_ptr;                  // 保存旧指针
        if (other) other->incStrong(this);  // 新对象引用计数 +1（先 inc）
        m_ptr = other;                      // 替换指针
        if (oldPtr) oldPtr->decStrong(this);// 旧对象引用计数 -1（后 dec）
        return *this;                       // "先 inc 后 dec" 保证自赋值安全
    }
 
    // ---------- 访问 ----------
    T* operator->() const { return m_ptr; } // 箭头运算符
    T& operator*() const { return *m_ptr; } // 解引用
    T* get() const { return m_ptr; }        // 获取裸指针
 
private:
    T* m_ptr;                               // 唯一成员：裸指针
                                            // sizeof(sp<T>) == sizeof(T*)
};

// RefBase::incStrong —— 增加强引用计数
void RefBase::incStrong(const void* id) const {
    weakref_impl* const refs = mRefs;       // mRefs 是 RefBase 内部的引用计数实现体
    refs->incWeak(id);                      // ★ 每次 incStrong 也会 incWeak
                                            //   保证弱引用计数 >= 强引用计数
 
    refs->addStrongRef(id);                 // Debug 构建下记录调用者信息（Release 为空操作）
 
    // 原子操作：强引用计数 +1，返回旧值
    const int32_t c = refs->mStrong.fetch_add(1, std::memory_order_relaxed);
 
    if (c != INITIAL_STRONG_VALUE) {
        // 非首次引用：普通 +1，直接返回
        return;
    }
 
    // ★ 首次引用（从 INITIAL_STRONG_VALUE 变化）：
    // 将强引用计数从 INITIAL_STRONG_VALUE+1 修正为 1
    refs->mStrong.fetch_sub(INITIAL_STRONG_VALUE,
                            std::memory_order_relaxed);
 
    // 回调通知：对象首次被强引用持有
    refs->mBase->onFirstRef();              // 子类可覆写此虚函数做初始化
}
 
// RefBase::decStrong —— 减少强引用计数
void RefBase::decStrong(const void* id) const {
    weakref_impl* const refs = mRefs;
    refs->removeStrongRef(id);              // Debug 构建下移除记录
 
    // 原子操作：强引用计数 -1，返回旧值
    const int32_t c = refs->mStrong.fetch_sub(1, std::memory_order_release);
 
    if (c == 1) {
        // ★ 旧值为 1 → 减后为 0 → 触发析构流程
        std::atomic_thread_fence(std::memory_order_acquire);
 
        // 回调通知：最后一个强引用即将释放
        refs->mBase->onLastStrongRef(id);
 
        // 根据生命周期策略决定是否 delete 对象
        int32_t flags = refs->mFlags.load(std::memory_order_relaxed);
        if ((flags & OBJECT_LIFETIME_MASK) == OBJECT_LIFETIME_STRONG) {
            // 默认策略：强引用控制生命周期 → delete this
            delete this;
        }
        // 若策略为 OBJECT_LIFETIME_WEAK，则不在此处 delete
        // 等到弱引用计数也归零时才释放
    }
 
    refs->decWeak(id);                      // ★ 与 incStrong 中的 incWeak 配对
}

// 定义在 RefBase.cpp 中
#define INITIAL_STRONG_VALUE (1 << 28)   // 0x10000000，约 2.68 亿

// ✅ 线程安全：不同线程各持有自己的 sp 拷贝
void threadA(sp<MyService> svc) {    // 拷贝传入，引用计数原子 +1
    svc->doWork();                   // 安全
}                                    // 退出时原子 -1
 
void threadB(sp<MyService> svc) {    // 同上
    svc->doWork();                   // 安全
}
 
// ❌ 非线程安全：多个线程同时读写「同一个 sp 变量」
sp<MyService> g_svc;                 // 全局 sp
 
void threadC() {
    g_svc = new MyService();         // 写 g_svc
}
 
void threadD() {
    sp<MyService> local = g_svc;     // 读 g_svc → 数据竞争！
    // 原因：sp 的赋值操作涉及「读指针 + incStrong」两步
    //       这两步合在一起并非原子操作
    //       另一个线程可能在中间替换了 g_svc 的指针
}
 
// ✅ 正确做法：对共享的 sp 变量本身加锁
std::mutex g_mutex;
void threadC_safe() {
    std::lock_guard<std::mutex> lock(g_mutex);
    g_svc = new MyService();         // 互斥写
}
void threadD_safe() {
    std::lock_guard<std::mutex> lock(g_mutex);
    sp<MyService> local = g_svc;     // 互斥读
}

// ====== 优势1：内存布局紧凑，Cache 友好 ======
// Android sp：对象和引用计数在「同一块内存」中（或紧邻）
// 访问计数时不需要额外的指针跳转（pointer indirection）
 
// RefBase 对象的内存布局（概念）:
// +-------------------+
// | RefBase::mRefs ---|--→ weakref_impl { mStrong, mWeak, mFlags, mBase }
// |                   |    （通常在构造时一次性分配）
// | MyService 成员    |
// | ...               |
// +-------------------+
 
// std::shared_ptr：T 对象 和 Control Block 可能在不同的堆地址
// 除非使用 make_shared 合并分配
 
// ====== 优势2：sp 自身只有一个指针，更轻量 ======
static_assert(sizeof(sp<MyService>) == sizeof(void*),
              "sp should be pointer-sized");    // ✅ 通过
// std::shared_ptr 通常是两个指针大小
static_assert(sizeof(std::shared_ptr<int>) == 2 * sizeof(void*),
              "shared_ptr is two pointers");    // ✅ 通常通过
 
// ====== 优势3：从裸指针可以安全地反向获取 sp ======
class MyService : public RefBase {
public:
    void publishSelf() {
        // RefBase 天然支持：从 this 安全构建 sp
        sp<MyService> self(this);   // ✅ 安全：引用计数嵌入对象，计数 +1
        someManager->register(self);
    }
};
 
// std::shared_ptr 要实现同样功能，必须继承 enable_shared_from_this：
class StdService : public std::enable_shared_from_this<StdService> {
public:
    void publishSelf() {
        auto self = shared_from_this();  // 需要已有 shared_ptr 管理 this
        someManager->register(self);
    }
};

// ====== 优势1：无类型约束 ======
std::shared_ptr<int> p1 = std::make_shared<int>(42);    // ✅ int 无需继承任何基类
std::shared_ptr<FILE> p2(fopen("a.txt", "r"), fclose);  // ✅ 支持自定义 deleter
 
// sp<int> ???  → ❌ 不可能，int 不继承 RefBase
 
// ====== 优势2：Custom Deleter 支持 ======
// 管理非 new 分配的资源（如文件句柄、mmap 内存等）
std::shared_ptr<void> gpuBuf(
    mapGpuMemory(size),                       // 自定义分配
    [](void* p) { unmapGpuMemory(p); }        // 自定义释放
);
// sp 做不到：它永远只会 delete this
 
// ====== 优势3：与标准库生态完美兼容 ======
std::vector<std::shared_ptr<Widget>> widgets;            // STL 容器
std::unordered_map<int, std::shared_ptr<Texture>> cache; // 标准关联容器
// sp 也可以放入 STL 容器，但在 Android 旧代码中更常见 Vector<sp<T>>

sp<MyService> g_service = new MyService();   // 全局 sp
 
// 线程1
void thread1() {
    sp<MyService> local = g_service;    // ① 读取全局 sp 并拷贝
    local->doWork();
}
 
// 线程2
void thread2() {
    g_service = new MyService();        // ② 替换全局 sp
}
 
// 线程3
void thread3() {
    sp<MyService> copy = g_service;     // ③ 读取全局 sp 并拷贝
    sp<MyService> copy2 = copy;         // ④ 拷贝局部 sp
}

#include <utils/RefBase.h>   // Android RefBase 体系头文件
#include <utils/StrongPointer.h>
 
using namespace android;
 
// 定义一个继承自 RefBase 的类，使其具备引用计数能力
class SensorService : public RefBase {
public:
    SensorService() {
        // 构造时打印日志，方便跟踪生命周期
        ALOGD("SensorService created");
    }
 
    virtual ~SensorService() {
        // 析构时打印日志，验证释放时机
        ALOGD("SensorService destroyed");
    }
 
    void start() {
        ALOGD("SensorService started");
    }
};
 
void demonstrateWeakPointer() {
    wp<SensorService> weakRef;          // 声明一个弱指针，初始为空
 
    {
        // 在内部作用域创建一个强指针，引用计数 mStrong=1, mWeak=1
        sp<SensorService> strongRef = sp<SensorService>::make();
 
        // 用强指针构造弱指针：mStrong 不变仍为1，mWeak 增至 2
        weakRef = strongRef;
 
        // 此时通过 promote() 一定能成功，因为 strongRef 还活着
        sp<SensorService> promoted = weakRef.promote();
        if (promoted != nullptr) {
            // promote 成功，mStrong 临时变为 2
            promoted->start();          // 安全访问对象方法
        }
        // promoted 离开作用域，mStrong 回到 1
    }
    // strongRef 离开作用域，mStrong 降为 0 → 对象被销毁
    // 此时 weakRef 还在，但它指向的对象已经 gone
 
    // 再次尝试提升：对象已销毁，promote() 返回 nullptr
    sp<SensorService> promoted = weakRef.promote();
    if (promoted == nullptr) {
        ALOGD("Object already destroyed, promote failed!");
    }
}

template <typename T>
class wp {
public:
    // === 构造函数族 ===
    wp();                                // 默认构造：空弱指针
    wp(T* other);                        // 从裸指针构造（调用 incWeak）
    wp(const wp<T>& other);              // 拷贝构造（调用 incWeak）
    wp(const sp<T>& other);              // 从强指针构造（仅调用 incWeak，不影响 mStrong）
 
    // === 析构函数 ===
    ~wp();                               // 调用 decWeak，弱引用计数减 1
 
    // === 赋值操作符 ===
    wp& operator=(T* other);             // 裸指针赋值
    wp& operator=(const wp<T>& other);   // 弱指针拷贝赋值
    wp& operator=(const sp<T>& other);   // 从强指针赋值
 
    // === 核心方法 ===
    sp<T> promote() const;               // 尝试提升为强指针（原子操作，线程安全）
 
    // === 辅助方法 ===
    void clear();                        // 手动释放弱引用（等价于赋值 nullptr）
 
    // ❌ 注意：没有 operator->() 和 operator*()
    // ❌ 无法直接访问底层对象
 
private:
    T*                  m_ptr;           // 指向目标对象的裸指针（但不能直接用）
    weakref_type*       m_refs;          // 指向引用计数管理结构
};

// frameworks/rs/cpp/util/RefBase.h (简化版)
template<typename T>
sp<T> wp<T>::promote() const {
    sp<T> result;                        // 创建一个空的强指针
    if (m_ptr &&                         // 裸指针不为空（曾经指向过一个对象）
        m_refs->attemptIncStrong(&result)) {  // 原子性尝试增加强引用计数
        result.set_pointer(m_ptr);       // 成功：将裸指针设置到 sp 中
    }
    return result;                       // 失败则返回空 sp (nullptr)
}

// system/core/libutils/RefBase.cpp (关键逻辑，精简注释版)
bool RefBase::weakref_type::attemptIncStrong(const void* id) {
    // ① 先无条件增加弱引用计数（保护 weakref_type 自身不被释放）
    incWeak(id);
 
    // ② 通过原子操作读取当前强引用计数
    // memory_order_relaxed: 仅需原子性，暂不需要内存序保证
    int32_t curCount = impl->mStrong.load(std::memory_order_relaxed);
 
    // ③ 核心循环：使用 CAS (Compare-And-Swap) 原子操作尝试 +1
    while (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {
        // 如果当前计数 > 0，说明对象还活着
        // CAS：如果 mStrong 仍然等于 curCount，则原子地将其设为 curCount+1
        // 如果在此期间其他线程修改了 mStrong，CAS 失败，curCount 被更新，循环重试
        if (impl->mStrong.compare_exchange_weak(
                curCount,                // expected: 当前读到的值
                curCount + 1,            // desired:  期望写入的值
                std::memory_order_relaxed)) {
            break;                       // CAS 成功，跳出循环
        }
        // CAS 失败：curCount 已被自动更新为最新值，继续循环重试
    }
 
    // ④ 判断 promote 是否成功
    if (curCount <= 0 || curCount == INITIAL_STRONG_VALUE) {
        // 分支 A：强引用计数已为 0，或者对象从未被强引用过
        // 这里需要根据对象的生命周期策略做进一步判断
        // 对于 OBJECT_LIFETIME_STRONG（默认策略）：
        //   如果 curCount <= 0，说明对象已被销毁 → promote 失败
 
        if (curCount <= 0) {
            // 对象已经析构，回滚之前 incWeak 的操作
            decWeak(id);
            return false;                // promote 失败
        }
 
        // 对于 INITIAL_STRONG_VALUE 的情况：首次强引用
        // 需要从 INITIAL_STRONG_VALUE 调整到 1
        // ...（省略首次引用逻辑）
    }
 
    // ⑤ 到达此处说明 CAS 成功，promote 完成
    // 此时 mStrong 已经 +1，对象不会被销毁
    return true;
}

// 线程 A：持有最后一个 sp，准备释放
void threadA(sp<SensorService>& lastStrongRef) {
    lastStrongRef = nullptr;             // decStrong → mStrong 降为 0 → 触发 delete
}
 
// 线程 B：持有 wp，准备使用对象
void threadB(wp<SensorService>& weakRef) {
    sp<SensorService> strong = weakRef.promote();  // 原子性尝试提升
    if (strong != nullptr) {
        // 如果 promote 成功，说明 mStrong 已经被原子地 +1
        // 即使线程 A 同时在执行，也不会出问题：
        //   情况1：promote 先执行成功 → mStrong 变为 2 → 线程 A 的 decStrong 只降为 1 → 对象安全
        //   情况2：线程 A 先完成 → mStrong 已为 0 → promote 的 CAS 发现 curCount <= 0 → 返回 nullptr
        strong->start();                 // 安全使用
    } else {
        ALOGD("Too late, object gone");  // 对象已销毁，优雅处理
    }
}

// ❌ 错误示范：双向强引用导致循环引用
class CameraClient;  // 前向声明
 
class CameraService : public RefBase {
public:
    // CameraService 用 sp 强引用 CameraClient（合理：父管理子的生命周期）
    sp<CameraClient> mClient;
 
    virtual ~CameraService() {
        ALOGD("~CameraService");         // 永远不会执行！
    }
};
 
class CameraClient : public RefBase {
public:
    // ❌ CameraClient 也用 sp 强引用 CameraService（问题根源！）
    sp<CameraService> mService;
 
    virtual ~CameraClient() {
        ALOGD("~CameraClient");          // 永远不会执行！
    }
};
 
void createCircularReference() {
    sp<CameraService> service = sp<CameraService>::make();
    // 此时: service->mStrong = 1
 
    sp<CameraClient> client = sp<CameraClient>::make();
    // 此时: client->mStrong = 1
 
    service->mClient = client;
    // 此时: client->mStrong = 2（service 外部 sp + CameraService::mClient）
 
    client->mService = service;
    // 此时: service->mStrong = 2（client 外部 sp + CameraClient::mService）
 
    // === 离开作用域 ===
    // client (外部sp) 析构 → client->mStrong = 2-1 = 1（≠0，不释放）
    // service (外部sp) 析构 → service->mStrong = 2-1 = 1（≠0，不释放）
    //
    // 结果：两个对象都无法释放 → 内存泄漏！ 💀
}

// ✅ 正确做法：子对象用 wp 回引父对象
class CameraClient;  // 前向声明
 
class CameraService : public RefBase {
public:
    // 父 → 子：强引用（sp），CameraService 管理 CameraClient 的生命周期
    sp<CameraClient> mClient;
 
    virtual ~CameraService() {
        ALOGD("~CameraService");         // ✅ 现在可以正确析构
    }
};
 
class CameraClient : public RefBase {
public:
    // ✅ 子 → 父：弱引用（wp），不影响 CameraService 的强引用计数
    wp<CameraService> mService;
 
    void notifyService() {
        // 需要用到 CameraService 时，先 promote
        sp<CameraService> service = mService.promote();
        if (service != nullptr) {
            // 对象还活着，安全使用
            ALOGD("Notifying CameraService...");
        } else {
            // CameraService 已销毁，优雅降级
            ALOGD("CameraService already gone, skip notification");
        }
    }
 
    virtual ~CameraClient() {
        ALOGD("~CameraClient");          // ✅ 可以正确析构
    }
};
 
void noMoreCircularReference() {
    sp<CameraService> service = sp<CameraService>::make();
    // service->mStrong = 1, service->mWeak = 1
 
    sp<CameraClient> client = sp<CameraClient>::make();
    // client->mStrong = 1, client->mWeak = 1
 
    service->mClient = client;
    // client->mStrong = 2, client->mWeak = 2
 
    client->mService = service;
    // service->mStrong 仍为 1 ← 关键！wp 不增加强计数
    // service->mWeak = 2       ← wp 只增加弱计数
 
    // === 离开作用域 ===
    // Step 1: 外部 sp<CameraClient> client 析构
    //         → client->mStrong = 2-1 = 1（CameraService::mClient 还持有）
 
    // Step 2: 外部 sp<CameraService> service 析构
    //         → service->mStrong = 1-1 = 0  ← 降为 0！
    //         → 触发 CameraService 析构
    //         → 析构中 mClient (sp) 释放 → client->mStrong = 1-1 = 0
    //         → 触发 CameraClient 析构
    //         → 析构中 mService (wp) 释放 → service->mWeak -= 1
    //
    // 结果：两个对象都被正确释放 ✅ 🎉
}

// === 案例 1: Binder 通信中的 Death Recipient ===
// BpBinder（代理端）用 wp 引用 DeathRecipient
// 源码位置: frameworks/native/libs/binder/BpBinder.cpp
class BpBinder : public IBinder {
    // Weak reference 列表，避免循环引用
    // 因为 DeathRecipient 通常也会持有一个 sp<IBinder>
    KeyedVector<wp<DeathRecipient>, ...> mObituaries;
};
 
// === 案例 2: SurfaceFlinger Layer 管理 ===
// Layer 弱引用 SurfaceFlinger，SurfaceFlinger 强引用 Layer
class Layer : public RefBase {
    wp<SurfaceFlinger> mFlinger;         // 子 → 父 用弱引用
};
 
class SurfaceFlinger : public RefBase {
    Vector<sp<Layer>> mLayers;           // 父 → 子 用强引用
};
 
// === 案例 3: Camera HAL Callback ===
// CameraDevice 弱引用 CameraDeviceCallbacks
class CameraDevice {
    wp<ICameraDeviceCallbacks> mCallbacks;  // 防止 callback 循环引用
    
    void sendResult() {
        sp<ICameraDeviceCallbacks> cb = mCallbacks.promote();  // 使用前 promote
        if (cb != nullptr) {
            cb->onResultReceived(result);
        }
    }
};

sp<MyObject> strong = sp<MyObject>::make();
wp<MyObject> weak = strong;
strong = nullptr;
sp<MyObject> result = weak.promote();

// RefBase::decStrong() 简化逻辑 —— OBJECT_LIFETIME_STRONG 模式
void RefBase::decStrong(const void* id) const
{
    weakref_impl* const refs = mRefs;            // 获取引用计数控制块
    refs->removeStrongRef(id);                     // Debug 用：移除强引用追踪记录
 
    // 原子递减强引用计数，并获取递减前的旧值
    const int32_t c = refs->mStrong.fetch_sub(1, std::memory_order_release);
 
    if (c == 1) {
        // 旧值为 1，说明递减后变为 0 —— 这是最后一个强引用
        std::atomic_thread_fence(std::memory_order_acquire); // 内存屏障，确保可见性
 
        // 检查生命周期标志
        refs->mFlags.load(std::memory_order_relaxed);        // 读取 flags
 
        // OBJECT_LIFETIME_STRONG 模式 (flags == 0x0000):
        // 直接调用 onLastStrongRef() 回调，然后 delete 对象
        refs->mBase->onLastStrongRef(id);                    // 生命周期回调：最后一个强引用释放
        delete this;                                          // 销毁对象本体！（调用析构函数）
    }
 
    // 注意：decStrong 内部也会调用 decWeak()
    // 因为每个强引用在 incStrong 时都会同步 incWeak
    refs->decWeak(id);                                       // 配对递减弱引用计数
}

// ============================================================
// 场景：OBJECT_LIFETIME_STRONG 模式下的完整生命周期
// ============================================================
 
// 假设 MyObject 继承自 RefBase（默认 STRONG 模式）
class MyObject : public RefBase {
public:
    MyObject()  { /* 构造 */ }                   // mStrong=INITIAL_STRONG_VALUE, mWeak=0
    ~MyObject() { /* 析构 */ }
};
 
void example() {
    // === 阶段 1：创建强指针 ===
    sp<MyObject> strong1 = sp<MyObject>::make();  // mStrong=1, mWeak=1
    //                                             // (incStrong 内部同时 incWeak)
 
    // === 阶段 2：创建弱指针 ===
    wp<MyObject> weak1(strong1);                  // mStrong=1, mWeak=2
    //                                             // (wp 构造仅 incWeak，不影响 mStrong)
 
    // === 阶段 3：再创建一个强指针 ===
    sp<MyObject> strong2 = strong1;               // mStrong=2, mWeak=3
    //                                             // (拷贝 sp，incStrong → mStrong+1, mWeak+1)
 
    // === 阶段 4：strong2 析构 ===
    strong2 = nullptr;                            // mStrong=1, mWeak=2
    //                                             // (decStrong → mStrong-1, decWeak → mWeak-1)
 
    // === 阶段 5：strong1 析构（关键时刻！）===
    strong1 = nullptr;                            // mStrong=0 → delete MyObject!
    //                                             // mWeak=1（weak1 还持有弱引用）
    //                                             // 对象已死！但 weakref_impl 控制块还活着
 
    // === 阶段 6：尝试 promote ===
    sp<MyObject> revived = weak1.promote();       // 返回 nullptr！对象已被销毁
    //                                             // STRONG 模式下，对象死了就是死了
 
    // === 阶段 7：weak1 析构 ===
    // weak1 离开作用域                             // mWeak=0 → delete weakref_impl
    //                                             // 控制块也被回收，彻底清理完毕
}

class LongLivedObject : public RefBase {
public:
    LongLivedObject() {
        // 在构造函数中切换为 WEAK 生命周期模式
        // 这会将内部 flags 设置为 OBJECT_LIFETIME_WEAK (0x0001)
        extendObjectLifetime(OBJECT_LIFETIME_WEAK);
    }
 
    virtual ~LongLivedObject() {
        // 析构——只有在强弱引用都归零时才会被调用
        ALOGD("LongLivedObject destroyed");
    }
 
    // 可选：重写生命周期回调
    virtual void onLastStrongRef(const void* id) override {
        // 强引用归零时被调用，但对象不会被销毁
        // 可以在这里做一些"降级"处理，比如暂停某些服务
        ALOGD("All strong refs gone, but I am still alive!");
    }
 
    virtual void onLastWeakRef(const void* id) override {
        // 弱引用也归零时被调用（对象即将被销毁前的最后回调）
        ALOGD("Truly dying now...");
    }
};

// RefBase::decStrong() 简化逻辑 —— OBJECT_LIFETIME_WEAK 模式
void RefBase::decStrong(const void* id) const
{
    weakref_impl* const refs = mRefs;
    refs->removeStrongRef(id);
 
    const int32_t c = refs->mStrong.fetch_sub(1, std::memory_order_release);
 
    if (c == 1) {
        // 强引用计数归零了！
        std::atomic_thread_fence(std::memory_order_acquire);
 
        const uint32_t flags = refs->mFlags.load(std::memory_order_relaxed);
 
        if ((flags & OBJECT_LIFETIME_MASK) == OBJECT_LIFETIME_WEAK) {
            // WEAK 模式：不 delete！仅调用回调通知
            refs->mBase->onLastStrongRef(id);     // 通知：强引用清零了
            // 注意：这里没有 delete this!          // 对象继续存活！
        } else {
            // STRONG 模式（默认）：立即销毁对象
            refs->mBase->onLastStrongRef(id);
            delete this;                           // 对象被销毁
        }
    }
 
    refs->decWeak(id);                             // 无论哪种模式，都要递减弱引用
}

// weakref_type::decWeak() 简化逻辑
void RefBase::weakref_type::decWeak(const void* id)
{
    weakref_impl* const impl = static_cast<weakref_impl*>(this);
    impl->removeWeakRef(id);
 
    // 原子递减弱引用计数
    const int32_t c = impl->mWeak.fetch_sub(1, std::memory_order_release);
 
    if (c == 1) {
        // 弱引用计数也归零了！
        std::atomic_thread_fence(std::memory_order_acquire);
 
        const uint32_t flags = impl->mFlags.load(std::memory_order_relaxed);
 
        if ((flags & OBJECT_LIFETIME_MASK) == OBJECT_LIFETIME_WEAK) {
            // WEAK 模式：现在才是真正销毁对象的时刻
            // （对象和控制块一起销毁）
            delete impl->mBase;                    // delete 对象本体（析构函数中会清理 impl）
        } else {
            // STRONG 模式：对象早已在 decStrong 中被删除
            // 这里只需要销毁控制块 weakref_impl
            delete impl;                           // 仅删除引用计数控制块
        }
    }
}

// weakref_type::attemptIncStrong() 简化 —— promote() 的核心实现
bool RefBase::weakref_type::attemptIncStrong(const void* id)
{
    incWeak(id);                                   // 先递增弱引用（保护控制块）
 
    weakref_impl* const impl = static_cast<weakref_impl*>(this);
 
    // 尝试用 CAS 循环递增强引用计数
    int32_t curCount = impl->mStrong.load(std::memory_order_relaxed);
 
    while (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {
        // 强引用计数 > 0：说明还有其他 sp 存在，安全地 +1
        if (impl->mStrong.compare_exchange_weak(
                curCount, curCount + 1, std::memory_order_relaxed)) {
            break;                                 // CAS 成功，promote 成功
        }
        // CAS 失败，说明有并发修改，重新读取并重试
    }
 
    if (curCount <= 0 || curCount == INITIAL_STRONG_VALUE) {
        // 强引用计数已经是 0（或从未被强引用过）
        // 这里就是两种模式的关键分歧点！
 
        const uint32_t flags = impl->mFlags.load(std::memory_order_relaxed);
 
        if ((flags & OBJECT_LIFETIME_MASK) == OBJECT_LIFETIME_STRONG) {
            // STRONG 模式：强引用归零意味着对象已被 delete
            // promote 失败！
            if (curCount <= 0) {
                decWeak(id);                       // 回滚之前的 incWeak
                return false;                      // 返回 false → sp 为 nullptr
            }
        } else {
            // WEAK 模式：即使强引用为 0，对象仍然存活
            // 可以安全地恢复强引用！
            if (!impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id)) {
                // onIncStrongAttempted() 返回 false → 对象拒绝被"复活"
                decWeak(id);
                return false;                      // 对象主动拒绝 promote
            }
            // 对象同意被 promote，将强引用计数从 0 提升为 1
            curCount = impl->mStrong.fetch_add(1, std::memory_order_relaxed);
        }
    }
 
    // ... 后续处理 ...
    return true;                                   // promote 成功
}

class SelectiveRevival : public RefBase {
public:
    SelectiveRevival() {
        extendObjectLifetime(OBJECT_LIFETIME_WEAK);   // 开启 WEAK 模式
    }
 
    // 当有人试图 promote() 一个强引用为 0 的对象时
    virtual bool onIncStrongAttempted(uint32_t flags, const void* id) override {
        // 自定义逻辑：例如检查对象是否已被标记为"废弃"
        if (mDiscarded) {
            ALOGW("Promote rejected: object is discarded");
            return false;                              // 拒绝 promote
        }
        return true;                                   // 允许 promote
    }
 
private:
    bool mDiscarded = false;
};

// ============================================================
// 完整对比演示：STRONG vs WEAK 模式
// ============================================================
 
// ---- STRONG 模式 (默认) ----
class StrongObj : public RefBase { };              // 默认 OBJECT_LIFETIME_STRONG
 
void testStrong() {
    wp<StrongObj> weakRef;
    {
        sp<StrongObj> strongRef = sp<StrongObj>::make();
        //                        mStrong=1, mWeak=1
        weakRef = strongRef;   // mStrong=1, mWeak=2
 
    }  // strongRef 析构 → mStrong=0 → delete 对象！mWeak=1
 
    sp<StrongObj> revived = weakRef.promote();
    // 结果：revived == nullptr
    // 原因：STRONG 模式，对象已随强引用归零而销毁
}
 
 
// ---- WEAK 模式 ----
class WeakObj : public RefBase {
public:
    WeakObj() {
        extendObjectLifetime(OBJECT_LIFETIME_WEAK);    // 切换为 WEAK 模式
    }
};
 
void testWeak() {
    wp<WeakObj> weakRef;
    {
        sp<WeakObj> strongRef = sp<WeakObj>::make();
        //                      mStrong=1, mWeak=1
        weakRef = strongRef;   // mStrong=1, mWeak=2
 
    }  // strongRef 析构 → mStrong=0 → 调用 onLastStrongRef() 但不 delete！mWeak=1
 
    sp<WeakObj> revived = weakRef.promote();
    // 结果：revived != nullptr ✅ 成功！
    // 原因：WEAK 模式，对象在弱引用归零前一直存活
    // 此时：mStrong=1 (promote 重新加了强引用), mWeak=2
 
}  // weakRef 和 revived 都析构 → mStrong=0, mWeak=0 → 对象和控制块一起被销毁

class RefBase {
protected:
    // --- 生命周期回调函数 ---
 
    // 当第一个强引用被创建时调用
    // 典型用途：延迟初始化（lazy init）
    virtual void onFirstRef();
 
    // 当最后一个强引用被释放时调用
    // STRONG 模式：在 delete this 之前调用
    // WEAK 模式：仅通知，对象不会被销毁
    virtual void onLastStrongRef(const void* id);
 
    // 当最后一个弱引用被释放时调用（仅 WEAK 模式有意义）
    // 在对象真正被 delete 之前调用
    virtual void onLastWeakRef(const void* id);
 
    // WEAK 模式专属：当 promote() 尝试恢复强引用时调用
    // 返回 true 允许 promote，返回 false 拒绝
    // 默认实现返回 true（允许）
    virtual bool onIncStrongAttempted(uint32_t flags, const void* id);
};

// ============================================================
//  STRONG 模式下的内存状态变迁
// ============================================================
//
//  【阶段 1】sp + wp 都存在
//  ┌───────────────────────┐     ┌────────────────────────┐
//  │    MyObject (堆上)     │ ←── │    weakref_impl         │
//  │  ┌─────────────────┐  │     │  ┌────────────────────┐ │
//  │  │  业务数据         │  │     │  │ mStrong = 1        │ │
//  │  │  mRefs ──────────┼──┼──→  │  │ mWeak   = 2        │ │
//  │  └─────────────────┘  │     │  │ mFlags  = 0x0000   │ │ ← STRONG
//  └───────────────────────┘     │  │ mBase ─────────────┼─┼──→ MyObject*
//           ↑                     │  └────────────────────┘ │
//      sp<T> ref                  └────────────────────────┘
//                                          ↑
//                                     wp<T> ref
//
//  【阶段 2】sp 全部析构，wp 还在
//  ┌───────────────────────┐
//  │  [已释放内存区域]       │     ┌────────────────────────┐
//  │   MyObject 已被 delete │     │    weakref_impl         │
//  │  xxxxxxxxxxxxxxxxxx   │     │  ┌────────────────────┐ │
//  └───────────────────────┘     │  │ mStrong = 0        │ │
//                                 │  │ mWeak   = 1        │ │
//                                 │  │ mBase → 悬空!      │ │
//                                 │  └────────────────────┘ │
//                                 └────────────────────────┘
//                                          ↑
//                                     wp<T> ref (promote→nullptr)
 
 
// ============================================================
//  WEAK 模式下的内存状态变迁
// ============================================================
//
//  【阶段 2'】sp 全部析构，wp 还在（对象依然存活！）
//  ┌───────────────────────┐     ┌────────────────────────┐
//  │    MyObject (仍在堆上!) │ ←── │    weakref_impl         │
//  │  ┌─────────────────┐  │     │  ┌────────────────────┐ │
//  │  │  业务数据完好      │  │     │  │ mStrong = 0        │ │
//  │  │  mRefs ──────────┼──┼──→  │  │ mWeak   = 1        │ │
//  │  └─────────────────┘  │     │  │ mFlags  = 0x0001   │ │ ← WEAK
//  └───────────────────────┘     │  │ mBase ─→ 有效!     │ │
//                                 │  └────────────────────┘ │
//                                 └────────────────────────┘
//                                          ↑
//                                     wp<T> ref (promote→成功✅)

// 为什么需要 Release-Acquire？直觉解释：
//
// Thread A (最后一个 decStrong):
//   对象.data = 42;                    // 修改对象
//   mStrong.fetch_sub(1, release);     // release: 把修改"推出去"
//   if (旧值 == 1) {
//       acquire_fence();               // acquire: 拉取其他线程的所有修改
//       delete this;                   // 安全！此时看到了对象的最终状态
//   }
//
// Thread B (稍早的 decStrong):
//   对象.name = "hello";               // 修改对象
//   mStrong.fetch_sub(1, release);     // release: 把修改"推出去"
//   // 旧值 > 1，不执行 delete
//
// 没有这对 fence，Thread A 执行 delete 时可能看不到 Thread B 的修改，
// 导致析构函数中访问到不一致的状态。

// ❌ 错误做法：假设 promote 一定成功
void callback(wp<StrongModeObj> weakObj) {
    sp<StrongModeObj> obj = weakObj.promote();
    obj->doSomething();                            // 如果 promote 返回 nullptr → 崩溃！
}
 
// ✅ 正确做法：始终检查 promote 返回值
void callback(wp<StrongModeObj> weakObj) {
    sp<StrongModeObj> obj = weakObj.promote();
    if (obj != nullptr) {                          // 必须检查！
        obj->doSomething();
    } else {
        ALOGW("Object already destroyed");         // 优雅降级
    }
}

// ⚠️ 注意：WEAK 模式下，如果忘记释放所有 wp，对象永远不会被销毁！
class LeakyCache {
    std::map<int, wp<WeakModeObj>> mCache;         // wp 永远不被清理
 
    // 如果 WeakModeObj 是 WEAK 模式，只要 mCache 持有 wp，
    // 对象就永远不会被销毁 → 实质上的内存泄漏！
    // STRONG 模式则不存在这个问题（对象随 sp 释放而销毁，wp 自动悬空）
};

wp<MyObj> weak;
{
    sp<MyObj> strong = sp<MyObj>::make();
    weak = strong;
}
sp<MyObj> revived = weak.promote();