【C++】Android中的同步机制

最新推荐文章于 2024-07-30 19:36:16 发布

会飞的代码UP

最新推荐文章于 2024-07-30 19:36:16 发布

阅读量3.6k

点赞数 1

分类专栏：编程语言 Android知识库文章标签： android Mutex Condition RWLock Barrier

本文链接：https://blog.csdn.net/ieearth/article/details/50525045

版权

编程语言同时被 2 个专栏收录

85 篇文章 8 订阅

订阅专栏

Android知识库

45 篇文章 20 订阅

订阅专栏

文章目录

在涉及多线程、多进程编程时，同步问题是不可避免的。在不同的操作系统或者项目中，都有自独特的同步手法，不过同步原理基本相同。在Android系统中，封装了几个同步类，下面来看一下这些同步类的源码是如何实现的。

1、Mutex

Mutex是个互斥锁，即MUTual EXclusion，对pthread的mutex进行了简单的封装，内部还有个嵌套类AutoLock，从名字上就可以看出这个类的功能是自动加锁解锁，使用原理正是基于变量的生命周期，对象创建时加锁，销毁时解锁。

Android中Mutex的源码路径为：

system/core/include/utils/Mutex.h

下面分析一下Mutex的源码实现。

// Mutex.h

// 宏定义惯例
#ifndef _LIBS_UTILS_MUTEX_H
#define _LIBS_UTILS_MUTEX_H

// C99引入的标准C库的头文件
// 定义了几种扩展的整数类型和宏
#include <stdint.h>

// 基本系统数据类型
#include <sys/types.h>

// 日期和时间相关函数
#include <time.h>

// 平台相关
// pthread即POSIX线程
// 定义了一系列线程及同步相关的接口
#if !defined(_WIN32)
# include <pthread.h>
#endif

// Android自定义了errno
#include <utils/Errors.h>

// Android自定义了时间格式转换函数
#include <utils/Timers.h>

// android名字空间
namespace android {

// Condition类前置声明
// 作为Mutex类的友元
class Condition;

/*
 * NOTE: This class is for code that builds on Win32.  Its usage is
 * deprecated for code which doesn't build for Win32.  New code which
 * doesn't build for Win32 should use std::mutex and std::lock_guard instead.
 *
 * Simple mutex class.  The implementation is system-dependent.
 *
 * The mutex must be unlocked by the thread that locked it.  They are not
 * recursive, i.e. the same thread can't lock it multiple times.
 */
class Mutex {
public:
    // PRIVATE限于同一进程内的多线程同步
    // SHARED支持进程间同步
    // 从下面的Mutex构造函数可以看出两者的区别
    enum {
        PRIVATE = 0,
        SHARED = 1
    };

	// 几个构造/析构函数
    Mutex();
    Mutex(const char* name);
    Mutex(int type, const char* name = NULL);
    ~Mutex();

	// 类似于pthread的lock/unlock/trylock
    status_t lock();
    void     unlock();
    status_t tryLock();

    // 平台相关
    // timedLock获取锁时限制了等待时间
#if defined(__ANDROID__)
    status_t timedLock(nsecs_t timeoutMilliseconds);
#endif

    // 自动加锁解锁
    class Autolock {
    public:
        // 构造对象时加锁
        inline Autolock(Mutex& mutex) : mLock(mutex)  { mLock.lock(); }
        inline Autolock(Mutex* mutex) : mLock(*mutex) { mLock.lock(); }
        // 销毁对象时解锁
        inline ~Autolock() { mLock.unlock(); }
    private:
        // 对象类型为引用时只能通过初始化列表进行初始化
        Mutex& mLock;
    };

private:
    // 友元声明
    friend class Condition;

    // 拷贝构造函数和赋值操作符私有声明而不定义
    // Mutex不能被拷贝
    Mutex(const Mutex&);
    Mutex& operator=(const Mutex&);

    // 平台相关
	// 非_WIN32时对pthread的mutex进行封装
#if !defined(_WIN32)
    pthread_mutex_t mMutex;
#else
    void  _init();
    void* mState;
#endif
};

// ---------------------------------------------------------------------------

#if !defined(_WIN32)

// 构造函数调用pthread_mutex_init初始化mutex
inline Mutex::Mutex() {
    pthread_mutex_init(&mMutex, NULL);
}

// 构造函数调用pthread_mutex_init初始化mutex
// __attribute__是GCC的一个特性
// unused表示其后的实参name没有被使用
inline Mutex::Mutex(__attribute__((unused)) const char* name) {
    pthread_mutex_init(&mMutex, NULL);
}

// 指定mutex类型的构造函数
// 当type为SHARED时
// 通过pthread_mutexattr_t设置其属性为PTHREAD_PROCESS_SHARED
// 表示mutex支持多进程
inline Mutex::Mutex(int type, __attribute__((unused)) const char* name) {
    if (type == SHARED) {
        pthread_mutexattr_t attr;
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
        pthread_mutex_init(&mMutex, &attr);
        pthread_mutexattr_destroy(&attr);
    } else {
        pthread_mutex_init(&mMutex, NULL);
    }
}

// 析构函数调用pthread_mutex_destroy销毁mutex对象
inline Mutex::~Mutex() {
    pthread_mutex_destroy(&mMutex);
}

// lock加锁时调用了pthread_mutex_lock
// 锁被占用时会阻塞
// 成功时返回0
// 失败时返回一个errno
// 这些errno和status_t类型在utils/Errors.h中定义
inline status_t Mutex::lock() {
    return -pthread_mutex_lock(&mMutex);
}

// unlock解锁时调用了pthread_mutex_unlock
inline void Mutex::unlock() {
    pthread_mutex_unlock(&mMutex);
}

// trylock加锁时调用了pthread_mutex_trylock
// 锁被占用时会直接返回二不会等待
inline status_t Mutex::tryLock() {
    return -pthread_mutex_trylock(&mMutex);
}

// 特有的timedLock
// 加锁阻塞时限制了等待的时间
// nsecs_t在utils/Timers.h中定义
// timespec结构体的两个成员是秒和纳秒
#if defined(__ANDROID__)
inline status_t Mutex::timedLock(nsecs_t timeoutNs) {
    const struct timespec ts = {
        /* .tv_sec = */ static_cast<time_t>(timeoutNs / 1000000000),
        /* .tv_nsec = */ static_cast<long>(timeoutNs % 1000000000),
    };
    return -pthread_mutex_timedlock(&mMutex, &ts);
}
#endif

#endif // !defined(_WIN32)

// ---------------------------------------------------------------------------

// AutoMutex惯用法：
// 在函数中需要加锁时先声明一个AutoMutex局部变量
// AutoMutex局部变量自动销毁时便会解锁
typedef Mutex::Autolock AutoMutex;

}; // namespace android

#endif // _LIBS_UTILS_MUTEX_H

2、Condition

Condition条件变量同样是对pthread的条件变量进行了封装，不过具体实现还使用了Mutex。当条件满足时直接返回，继续执行未完成的操作，否则就会等待，直到条件满足而被唤醒。

Android中Condition的源码路径为：

system/core/include/utils/Condition.h

下面分析一下Condition的源码实现。

// Condition.h

#ifndef _LIBS_UTILS_CONDITION_H
#define _LIBS_UTILS_CONDITION_H

#include <stdint.h>
#include <sys/types.h>
#include <time.h>

#if !defined(_WIN32)
# include <pthread.h>
#endif

#include <utils/Errors.h>
#include <utils/Mutex.h>
#include <utils/Timers.h>

namespace android {

// DO NOT USE: please use std::condition_variable instead.

/*
 * Condition variable class.  The implementation is system-dependent.
 *
 * Condition variables are paired up with mutexes.  Lock the mutex,
 * call wait(), then either re-wait() if things aren't quite what you want,
 * or unlock the mutex and continue.  All threads calling wait() must
 * use the same mutex for a given Condition.
 *
 * On Android and Apple platforms, these are implemented as a simple wrapper
 * around pthread condition variables.  Care must be taken to abide by
 * the pthreads semantics, in particular, a boolean predicate must
 * be re-evaluated after a wake-up, as spurious wake-ups may happen.
 */
// 条件变量实际上是对互斥锁的一种扩展
// 条件变量允许线程阻塞并等待其它的线程发信号将其唤醒
class Condition {
public:
	// PRIVATE和SHARED的含义同Mutex中的用法
    enum {
        PRIVATE = 0,
        SHARED = 1
    };

    // 唤醒等待者
    // 唤醒一个还是全部
    // 对应于signal和broadcast
    enum WakeUpType {
        WAKE_UP_ONE = 0,
        WAKE_UP_ALL = 1
    };

    Condition();
    Condition(int type);
    ~Condition();

    // 阻塞式等待条件变量或者设定延时等待时间
    status_t wait(Mutex& mutex);
    status_t waitRelative(Mutex& mutex, nsecs_t reltime);

    // 唤醒单个等待者或者所有等待者
    void signal();
    void signal(WakeUpType type) {
        if (type == WAKE_UP_ONE) {
            signal();
        } else {
            broadcast();
        }
    }
    void broadcast();

private:
// 封装了pthread_cond_t条件变量
#if !defined(_WIN32)
    pthread_cond_t mCond;
#else
    void* mState;
#endif
};

// ---------------------------------------------------------------------------

#if !defined(_WIN32)

// 构造函数调用pthread_cond_init初始化条件变量
inline Condition::Condition() {
    pthread_cond_init(&mCond, NULL);
}

// 原理同Mutex
// 当类型为SHARED时
// 通过pthread_condattr_t设置其属性为PTHREAD_PROCESS_SHARED
// 以支持进程间的同步
inline Condition::Condition(int type) {
    if (type == SHARED) {
        pthread_condattr_t attr;
        pthread_condattr_init(&attr);
        pthread_condattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
        pthread_cond_init(&mCond, &attr);
        pthread_condattr_destroy(&attr);
    } else {
        pthread_cond_init(&mCond, NULL);
    }
}

// 析构函数调用pthread_cond_destroy销毁条件变量
inline Condition::~Condition() {
    pthread_cond_destroy(&mCond);
}

// 调用pthread_cond_wait等待条件变量
// 这个wait机制比较有意思
// wait前首先要给mutex加锁
// wait内部会先给mutex解锁然后等待
// 直到条件满足时再给mutex加锁并返回
// 这些操作是一个原子操作
inline status_t Condition::wait(Mutex& mutex) {
    return -pthread_cond_wait(&mCond, &mutex.mMutex);
}

// timedWait设定了延时等待时间
inline status_t Condition::waitRelative(Mutex& mutex, nsecs_t reltime) {
#if defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE)
    struct timespec ts;
    ts.tv_sec  = reltime / 1000000000;
    ts.tv_nsec = reltime % 1000000000;
    return -pthread_cond_timedwait_relative_np(&mCond, &mutex.mMutex, &ts);
#else // HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE
    struct timespec ts;
#if defined(__linux__)
    clock_gettime(CLOCK_REALTIME, &ts);
#else // __APPLE__
    struct timeval t;
    gettimeofday(&t, NULL);
    ts.tv_sec = t.tv_sec;
    ts.tv_nsec= t.tv_usec * 1000;
#endif
    ts.tv_sec  += reltime / 1000000000;
    ts.tv_nsec += reltime % 1000000000;
    if (ts.tv_nsec >= 1000000000) {
        ts.tv_nsec -= 1000000000;
        ts.tv_sec  += 1;
    }
    return -pthread_cond_timedwait(&mCond, &mutex.mMutex, &ts);
#endif // HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE
}

// 调用pthread_cond_signal唤醒某个等待者
inline void Condition::signal() {
    pthread_cond_signal(&mCond);
}

// 调用pthread_cond_broadcast唤醒所有等待者
inline void Condition::broadcast() {
    pthread_cond_broadcast(&mCond);
}

#endif // !defined(_WIN32)

}; // namespace android

#endif // _LIBS_UTILS_CONDITON_H

3、RWLock

RWLock即读写锁，同样是对pthread的rwlock进行了封装，基本原理是可以多个线程占用读锁，但是只能一个线程占用写锁。

Android中RWLock的源码路径为：

system/core/include/utils/RWLock.h

下面分析一下RWLock的源码实现，代码结构与Mutex的很相似。

// RWLock.h

#ifndef _LIBS_UTILS_RWLOCK_H
#define _LIBS_UTILS_RWLOCK_H

#include <stdint.h>
#include <sys/types.h>

#if !defined(_WIN32)
# include <pthread.h>
#endif

#include <utils/Errors.h>

// 定义了线程相关的数据类型和优先级
#include <utils/ThreadDefs.h>

namespace android {

#if !defined(_WIN32)

/*
 * Simple mutex class.  The implementation is system-dependent.
 *
 * The mutex must be unlocked by the thread that locked it.  They are not
 * recursive, i.e. the same thread can't lock it multiple times.
 */
// RWLock读写锁的特点是：
// 当读写锁处于写模式时
// 其后的读锁/写锁都会阻塞
// 当读写锁处于读模式时
// 其后的读锁仍可以获得控制权
// 但写锁将被阻塞以及这个写锁之后的读锁也会被阻塞
class RWLock {
public:
    // 同样用法的enum
    enum {
        PRIVATE = 0,
        SHARED = 1
    };

    // 类似于Mutex的构造/析构函数
    RWLock();
    RWLock(const char* name);
    RWLock(int type, const char* name = NULL);
    ~RWLock();

    // 几个读锁/写锁及解锁函数
    status_t readLock();
    status_t tryReadLock();
    status_t writeLock();
    status_t tryWriteLock();
    void     unlock();

    // 类似于Mutex的自动读锁
    class AutoRLock {
    public:
        inline AutoRLock(RWLock& rwlock) : mLock(rwlock)  { mLock.readLock(); }
        inline ~AutoRLock() { mLock.unlock(); }
    private:
        RWLock& mLock;
    };

    // 类似于Mutex的自动写锁
    class AutoWLock {
    public:
        inline AutoWLock(RWLock& rwlock) : mLock(rwlock)  { mLock.writeLock(); }
        inline ~AutoWLock() { mLock.unlock(); }
    private:
        RWLock& mLock;
    };

private:
    // 类似于Mutex的用法
    // 禁止RWLock拷贝
            RWLock(const RWLock&);
    RWLock& operator=(const RWLock&);

    // 对pthread_rwlock_t进行了封装
    pthread_rwlock_t mRWLock;
};

// 构造函数调用pthread_rwlock_init对读写锁进行初始化
inline RWLock::RWLock() {
    pthread_rwlock_init(&mRWLock, NULL);
}

// 构造函数调用pthread_rwlock_init对读写锁进行初始化
// unused的name没有实际用处
// 猜想大概是个备用参数
inline RWLock::RWLock(__attribute__((unused)) const char* name) {
    pthread_rwlock_init(&mRWLock, NULL);
}

// 当type为SHARED时
// 通过对应的pthread_rwlockattr_t设置其属性为PTHREAD_PROCESS_SHARED
// 以支持跨进程的同步
inline RWLock::RWLock(int type, __attribute__((unused)) const char* name) {
    if (type == SHARED) {
        pthread_rwlockattr_t attr;
        pthread_rwlockattr_init(&attr);
        pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
        pthread_rwlock_init(&mRWLock, &attr);
        pthread_rwlockattr_destroy(&attr);
    } else {
        pthread_rwlock_init(&mRWLock, NULL);
    }
}

// 析构函数调用pthread_rwlock_destroy销毁读写锁
inline RWLock::~RWLock() {
    pthread_rwlock_destroy(&mRWLock);
}

// 调用pthread_rwlock_rdlock以获取读锁
inline status_t RWLock::readLock() {
    return -pthread_rwlock_rdlock(&mRWLock);
}

// 调用pthread_rwlock_tryrdlock以获取读锁并不会阻塞
inline status_t RWLock::tryReadLock() {
    return -pthread_rwlock_tryrdlock(&mRWLock);
}

// 调用pthread_rwlock_wrlock以获取写锁
inline status_t RWLock::writeLock() {
    return -pthread_rwlock_wrlock(&mRWLock);
}

// 调用pthread_rwlock_trywrlock以获取写锁并不会阻塞
inline status_t RWLock::tryWriteLock() {
    return -pthread_rwlock_trywrlock(&mRWLock);
}

// 调用pthread_rwlock_unlock以解锁
inline void RWLock::unlock() {
    pthread_rwlock_unlock(&mRWLock);
}

#endif // !defined(_WIN32)

// ---------------------------------------------------------------------------
}; // namespace android
// ---------------------------------------------------------------------------

#endif // _LIBS_UTILS_RWLOCK_H

4、Barrier

Barrier是基于Mutex和Condition实现的一个模型，专门为SurfaceFlinger设计，用起来更加简单，而不是像Mutex和Condition那样作为一个通用的Utility。

Android中Barrier的源码路径为：

framework/native/services/surfaceflinger/Barrier.h

下面分析一下Barrier 的源码实现。

// Barrier.h

#ifndef ANDROID_BARRIER_H
#define ANDROID_BARRIER_H

#include <stdint.h>
#include <sys/types.h>
#include <utils/threads.h>

namespace android {

// Barrier集合了Mutex和Condition
// 所谓的条件变量通过enum值OPENED和CLOSED实现
// 提供了3个函数open/close/wait
// 这3个函数都对state进行了读/写
// 所以需要加锁保护
// 否则会造成死锁等意想不到的现象
class Barrier
{
public:
    // 初始状态为CLOSED
    inline Barrier() : state(CLOSED) { }
    inline ~Barrier() { }

    // open函数设置state为OPENED
    // 调用broadcast函数解除wait函数的阻塞状态
    void open() {
        Mutex::Autolock _l(lock);
        state = OPENED;
        cv.broadcast();
    }

    // close函数重置state为CLOSED
    // 这时将阻塞wait函数
    void close() {
        Mutex::Autolock _l(lock);
        state = CLOSED;
    }

    // 当state为OPEND时
    // wait被唤醒
    // 从而退出wait
    void wait() const {
        Mutex::Autolock _l(lock);
        while (state == CLOSED) {
            cv.wait(lock);
        }
    }
private:
    enum { OPENED, CLOSED };
    mutable  Mutex     lock;
    mutable  Condition cv;
    volatile int       state;
};

}; // namespace android

#endif // ANDROID_BARRIER_H