iOS - 内存屏障的使用场景

内存屏障的使用是为了解决以下几个关键问题：

1. CPU 乱序执行

// 没有内存屏障时，CPU 可能乱序执行
void example() {
    // 这两行代码可能被 CPU 重排序
    a = 1;        // 操作1
    flag = true;  // 操作2
}

// 使用内存屏障确保顺序
void safeExample() {
    a = 1;
    OSMemoryBarrier();  // 确保 a = 1 在 flag = true 之前完成
    flag = true;
}

2. 多核 CPU 的缓存一致性

// 多核 CPU 场景
class SharedData {
    int value;
    spinlock_t lock;
    
    void write() {
        lock.lock();
        value = 42;
        OSMemoryBarrier();  // 确保其他 CPU 核心能看到更新
        lock.unlock();
    }
    
    int read() {
        lock.lock();
        OSMemoryBarrier();  // 确保读取到最新值
        int result = value;
        lock.unlock();
        return result;
    }
};

3. 编译器优化重排

// 编译器可能优化重排代码
void compilerReorder() {
    // 编译器可能重排这些操作
    obj->value = 1;
    obj->flag = true;
    obj->count++;
}

// 使用内存屏障防止重排
void safeOrder() {
    obj->value = 1;
    OSMemoryBarrier();  // 防止编译器重排
    obj->flag = true;
    OSMemoryBarrier();
    obj->count++;
}

4. 多线程数据同步

// 线程间的数据同步
class ThreadSafe {
    atomic_bool initialized = false;
    Data* sharedData;
    
    void initialize() {
        sharedData = new Data();
        OSMemoryBarrier();  // 确保 sharedData 初始化完成
        initialized = true;
    }
    
    void use() {
        if (initialized) {
            OSMemoryBarrier();  // 确保看到完整的 sharedData
            sharedData->process();
        }
    }
};

5. 锁的实现

// 自旋锁实现中的内存屏障
static ALWAYS_INLINE void
OSSpinLockUnlock(volatile OSSpinLock *lock) {
    OSMemoryBarrierBeforeUnlock();  // 确保之前的写操作都完成
    lock->value = 0;  // 解锁
}

6. 原子操作保证

// 原子操作需要内存屏障保证
static ALWAYS_INLINE int32_t 
OSAtomicIncrement32Barrier(volatile int32_t *value) {
    // 带内存屏障的原子增操作
    return __sync_fetch_and_add(value, 1) + 1;
}

7. 可见性保证

// 确保修改对其他线程可见
class VisibilityExample {
    int sharedValue;
    
    void modify() {
        sharedValue = 100;
        OSMemoryBarrier();  // 确保修改对其他线程可见
        notifyOtherThreads();
    }
};

8. 防止指令重排的实际场景

// 单例模式的实现
class Singleton {
    static Singleton* instance;
    
    static Singleton* getInstance() {
        if (!instance) {
            lock();
            if (!instance) {
                Singleton* temp = new Singleton();
                OSMemoryBarrier();  // 防止初始化和赋值重排
                instance = temp;
            }
            unlock();
        }
        return instance;
    }
};

使用内存屏障的原因总结：

1. 防止重排序：

• CPU 指令重排

• 编译器优化重排

• 内存访问重排

2. 保证可见性：

• 多核 CPU 缓存同步
• 线程间数据同步

• 内存更新的传播

3. 实现同步原语：

• 锁的实现

• 原子操作

• 线程同步

4. 解决硬件架构差异：

• 不同 CPU 架构的内存模型

• 缓存一致性协议

• 多核通信

这些机制确保了多线程程序的正确性和可靠性。