本文共 30584 字，大约阅读时间需要 101 分钟。

在Android ICS中，pthead库对应的路径为：

Android\bionic\libc\bionic\pthread.c

Android\bionic\libc\bionic\pthread-atfork.c

Android\bionic\libc\bionic\pthread-rwlocks.c

Android\bionic\libc\bionic\pthread-timers.c

Android\bionic\libc\bionic\pthread_internal.h

Android\bionic\libc\include\pthread.h

其中mutex在pthread.c中，相关的API有：

//pthread mutexattr 操作int pthread_mutexattr_init(pthread_mutexattr_t *attr);int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type);int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int  pshared);int pthread_mutexattr_getpshared(pthread_mutexattr_t *attr, int *pshared);//pthread mutex 操作int pthread_mutex_init(pthread_mutex_t *mutex,                       const pthread_mutexattr_t *attr);int pthread_mutex_destroy(pthread_mutex_t *mutex);int pthread_mutex_lock(pthread_mutex_t *mutex);int pthread_mutex_unlock(pthread_mutex_t *mutex);int pthread_mutex_trylock(pthread_mutex_t *mutex);int pthread_mutex_timedlock(pthread_mutex_t *mutex, struct timespec*  ts);

pthread_mutex_t对应一个结构体，包含一个int字段

typedef struct{    int volatile value;} pthread_mutex_t;

int字段分为5个部分，

/*

a mutex is implemented as a 32-bit integer holding the following fields

 * * bits:     name     description

* 31-16     tid      owner thread's kernel id (recursive and errorcheck only)

 * 15-14     type     mutex type

* 13           shared   process-shared flag

* 12-2       counter  counter of recursive mutexes

* 1-0         state    lock state (0, 1 or 2)

*/

定义了一些macro来获得各个部分，其中mutex的type分为3类，有Normal, Recursive, Errorcheck，Recursize允许递归，Errorcheck会检测当前的状态。

#define  MUTEX_OWNER(m)  (((m)->value >> 16) & 0xffff)#define  MUTEX_COUNTER(m) (((m)->value >> 2) & 0xfff)#define  MUTEX_TYPE_MASK       0xc000#define  MUTEX_TYPE_NORMAL     0x0000#define  MUTEX_TYPE_RECURSIVE  0x4000#define  MUTEX_TYPE_ERRORCHECK 0x8000#define  MUTEX_COUNTER_SHIFT  2#define  MUTEX_COUNTER_MASK   0x1ffc#define  MUTEX_SHARED_MASK    0x2000enum {    PTHREAD_MUTEX_NORMAL = 0,    PTHREAD_MUTEX_RECURSIVE = 1,    PTHREAD_MUTEX_ERRORCHECK = 2,    PTHREAD_MUTEX_ERRORCHECK_NP = PTHREAD_MUTEX_ERRORCHECK,    PTHREAD_MUTEX_RECURSIVE_NP  = PTHREAD_MUTEX_RECURSIVE,    PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL};

1 Mutex属性

pthread_mutexattr_t用来描述mutex的属性，

typedef long pthread_mutexattr_t;

属性包含了mutex的type，以及sharedflag。对应于mutex_t

 * 15-14     type     mutex type

 * 13           shared   process-shared flag

/* a mutex attribute holds the following fields

 *  * bits:     name       description  * 0-3       type       type of mutex  * 4         shared     process-shared flag  */ #define  MUTEXATTR_TYPE_MASK   0x000f #define  MUTEXATTR_SHARED_MASK 0x0010

#define PTHREAD_PROCESS_PRIVATE  0 #define PTHREAD_PROCESS_SHARED   1

1.1 init和destory

init将type设置为Default，也就是Normal（0）也就是，type=Normal， shared  为Private

int pthread_mutex_init(pthread_mutex_t *mutex,                       const pthread_mutexattr_t *attr){    int value = 0;    if (mutex == NULL)        return EINVAL;    if (__likely(attr == NULL)) {        mutex->value = MUTEX_TYPE_NORMAL;        return 0;    }    if ((*attr & MUTEXATTR_SHARED_MASK) != 0)        value |= MUTEX_SHARED_MASK;    switch (*attr & MUTEXATTR_TYPE_MASK) {    case PTHREAD_MUTEX_NORMAL:        value |= MUTEX_TYPE_NORMAL;        break;    case PTHREAD_MUTEX_RECURSIVE:        value |= MUTEX_TYPE_RECURSIVE;        break;    case PTHREAD_MUTEX_ERRORCHECK:        value |= MUTEX_TYPE_ERRORCHECK;        break;    default:        return EINVAL;    }    mutex->value = value;    return 0;}//destory将attr置为-1int pthread_mutex_destroy(pthread_mutex_t *mutex){    int ret;    /* use trylock to ensure that the mutex value is     * valid and is not already locked. */    ret = pthread_mutex_trylock(mutex);    if (ret != 0)        return ret;    mutex->value = 0xdead10cc;    return 0;}

1.2 settype 和gettype

对pthread_mutexattr_t的type字段进行取值和赋值

int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type){    if (attr) {        int  atype = (*attr & MUTEXATTR_TYPE_MASK);         if (atype >= PTHREAD_MUTEX_NORMAL &&             atype <= PTHREAD_MUTEX_ERRORCHECK) {            *type = atype;            return 0;        }    }    return EINVAL;}int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type){    if (attr && type >= PTHREAD_MUTEX_NORMAL &&                type <= PTHREAD_MUTEX_ERRORCHECK ) {        *attr = (*attr & ~MUTEXATTR_TYPE_MASK) | type;        return 0;    }    return EINVAL;}

1.3 setpshared和getpshared

int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int  pshared){    if (!attr)        return EINVAL;    switch (pshared) {    case PTHREAD_PROCESS_PRIVATE:        *attr &= ~MUTEXATTR_SHARED_MASK;        return 0;    case PTHREAD_PROCESS_SHARED:        /* our current implementation of pthread actually supports shared         * mutexes but won't cleanup if a process dies with the mutex held.         * Nevertheless, it's better than nothing. Shared mutexes are used         * by surfaceflinger and audioflinger.         */        *attr |= MUTEXATTR_SHARED_MASK;        return 0;    }    return EINVAL;}int pthread_mutexattr_getpshared(pthread_mutexattr_t *attr, int *pshared){    if (!attr || !pshared)        return EINVAL;    *pshared = (*attr & MUTEXATTR_SHARED_MASK) ? PTHREAD_PROCESS_SHARED                                               : PTHREAD_PROCESS_PRIVATE;    return 0;}

2 Mutex实现

2.1 Mutex init和 destory

如果attr==NULL，则采用默认属性, type =normal, shared = private,

否则，感觉属性的type和shared进行设置

int pthread_mutex_init(pthread_mutex_t *mutex,                       const pthread_mutexattr_t *attr){    int value = 0;    if (mutex == NULL)        return EINVAL;    if (__likely(attr == NULL)) {        mutex->value = MUTEX_TYPE_NORMAL;        return 0;    }    if ((*attr & MUTEXATTR_SHARED_MASK) != 0)        value |= MUTEX_SHARED_MASK;    switch (*attr & MUTEXATTR_TYPE_MASK) {    case PTHREAD_MUTEX_NORMAL:        value |= MUTEX_TYPE_NORMAL;        break;    case PTHREAD_MUTEX_RECURSIVE:        value |= MUTEX_TYPE_RECURSIVE;        break;    case PTHREAD_MUTEX_ERRORCHECK:        value |= MUTEX_TYPE_ERRORCHECK;        break;    default:        return EINVAL;    }    mutex->value = value;    return 0;}如果mutex当前不被lock，则设置value为0xdead10ccint pthread_mutex_destroy(pthread_mutex_t *mutex){    int ret;    /* use trylock to ensure that the mutex value is     * valid and is not already locked. */    ret = pthread_mutex_trylock(mutex);    if (ret != 0)        return ret;    mutex->value = 0xdead10cc;    return 0;}

2.2 lock, unlock, trylock, timedlock

int pthread_mutex_lock(pthread_mutex_t *mutex){    int mtype, tid, new_lock_type, shared;    if (__unlikely(mutex == NULL))        return EINVAL;    mtype = (mutex->value & MUTEX_TYPE_MASK);    shared = (mutex->value & MUTEX_SHARED_MASK);    /* Handle normal case first */   if ( __likely(mtype == MUTEX_TYPE_NORMAL) ) {//type为normal，        _normal_lock(mutex);        return 0;    }    /* Do we already own this recursive or error-check mutex ? */    tid = __get_thread()->kernel_id;   if ( tid == MUTEX_OWNER(mutex) )//已经持有mutex，递归的情况    {        int  oldv, counter;        if (mtype == MUTEX_TYPE_ERRORCHECK) {            /* trying to re-lock a mutex we already acquired */            return EDEADLK;        }        /*         * We own the mutex, but other threads are able to change         * the contents (e.g. promoting it to "contended"), so we         * need to hold the global lock.         */    _recursive_lock();//更新counter        oldv         = mutex->value;        counter      = (oldv + (1 << MUTEX_COUNTER_SHIFT)) & MUTEX_COUNTER_MASK;        mutex->value = (oldv & ~MUTEX_COUNTER_MASK) | counter;        _recursive_unlock();        return 0;    }    /* We don't own the mutex, so try to get it.     *     * First, we try to change its state from 0 to 1, if this     * doesn't work, try to change it to state 2.     */    new_lock_type = 1;    /* compute futex wait opcode and restore shared flag in mtype */    mtype |= shared;    for (;;) {        int  oldv;        _recursive_lock();        oldv = mutex->value;        if (oldv == mtype) { /* uncontended released lock => 1 or 2 */            mutex->value = ((tid << 16) | mtype | new_lock_type);        } else if ((oldv & 3) == 1) { /* locked state 1 => state 2 */            oldv ^= 3;            mutex->value = oldv;        }        _recursive_unlock();        if (oldv == mtype)            break;        /*         * The lock was held, possibly contended by others.  From         * now on, if we manage to acquire the lock, we have to         * assume that others are still contending for it so that         * we'll wake them when we unlock it.         */        new_lock_type = 2;        __futex_wait_ex(&mutex->value, shared, oldv, NULL);    }    return 0;}

normal 的情况

/* * Lock a non-recursive mutex. * * As noted above, there are three states: *   0 (unlocked, no contention) *   1 (locked, no contention) *   2 (locked, contention) * * Non-recursive mutexes don't use the thread-id or counter fields, and the * "type" value is zero, so the only bits that will be set are the ones in * the lock state field. */static __inline__ void_normal_lock(pthread_mutex_t*  mutex){    /* We need to preserve the shared flag during operations */    int  shared = mutex->value & MUTEX_SHARED_MASK;    /*     * The common case is an unlocked mutex, so we begin by trying to     * change the lock's state from 0 to 1.  __atomic_cmpxchg() returns 0     * if it made the swap successfully.  If the result is nonzero, this     * lock is already held by another thread.     */        if (__atomic_cmpxchg(shared|0, shared|1, &mutex->value ) != 0) {        /*         * We want to go to sleep until the mutex is available, which         * requires promoting it to state 2.  We need to swap in the new         * state value and then wait until somebody wakes us up.         *         * __atomic_swap() returns the previous value.  We swap 2 in and         * see if we got zero back; if so, we have acquired the lock.  If         * not, another thread still holds the lock and we wait again.         *         * The second argument to the __futex_wait() call is compared         * against the current value.  If it doesn't match, __futex_wait()         * returns immediately (otherwise, it sleeps for a time specified         * by the third argument; 0 means sleep forever).  This ensures         * that the mutex is in state 2 when we go to sleep on it, which         * guarantees a wake-up call.         */    while (__atomic_swap(shared|2, &mutex->value ) != (shared|0))//等待muex            __futex_wait_ex(&mutex->value, shared, shared|2, 0);    }    ANDROID_MEMBAR_FULL();}

在recursive的情况下，需要使用mutex来包含counter，

static pthread_mutex_t  __recursive_lock = PTHREAD_MUTEX_INITIALIZER;static void_recursive_lock(void){    _normal_lock(&__recursive_lock);}static void_recursive_unlock(void){    _normal_unlock(&__recursive_lock );}

unlock的情况

int pthread_mutex_unlock(pthread_mutex_t *mutex){    int mtype, tid, oldv, shared;    if (__unlikely(mutex == NULL))        return EINVAL;    mtype  = (mutex->value & MUTEX_TYPE_MASK);    shared = (mutex->value & MUTEX_SHARED_MASK);    /* Handle common case first */    if (__likely(mtype == MUTEX_TYPE_NORMAL)) {//normal        _normal_unlock(mutex);        return 0;    }    /* Do we already own this recursive or error-check mutex ? */    tid = __get_thread()->kernel_id;    if ( tid != MUTEX_OWNER(mutex) )//error check的情况，错误退出        return EPERM;    /* We do, decrement counter or release the mutex if it is 0 */    _recursive_lock();    oldv = mutex->value;    if (oldv & MUTEX_COUNTER_MASK) {        mutex->value = oldv - (1 << MUTEX_COUNTER_SHIFT);        oldv = 0;    } else {        mutex->value = shared | mtype;    }    _recursive_unlock();    /* Wake one waiting thread, if any */   if ((oldv & 3) == 2) {        __futex_wake_ex(&mutex->value, shared, 1);    }    return 0;}/* * Release a non-recursive mutex.  The caller is responsible for determining * that we are in fact the owner of this lock. */static __inline__ void_normal_unlock(pthread_mutex_t*  mutex){    ANDROID_MEMBAR_FULL();    /* We need to preserve the shared flag during operations */    int  shared = mutex->value & MUTEX_SHARED_MASK;    /*     * The mutex state will be 1 or (rarely) 2.  We use an atomic decrement     * to release the lock.  __atomic_dec() returns the previous value;     * if it wasn't 1 we have to do some additional work.     */    if (__atomic_dec(&mutex->value) != (shared|1)) {        /*         * Start by releasing the lock.  The decrement changed it from         * "contended lock" to "uncontended lock", which means we still         * hold it, and anybody who tries to sneak in will push it back         * to state 2.         *         * Once we set it to zero the lock is up for grabs.  We follow         * this with a __futex_wake() to ensure that one of the waiting         * threads has a chance to grab it.         *         * This doesn't cause a race with the swap/wait pair in         * _normal_lock(), because the __futex_wait() call there will         * return immediately if the mutex value isn't 2.         */        mutex->value = shared;        /*         * Wake up one waiting thread.  We don't know which thread will be         * woken or when it'll start executing -- futexes make no guarantees         * here.  There may not even be a thread waiting.         *         * The newly-woken thread will replace the 0 we just set above         * with 2, which means that when it eventually releases the mutex         * it will also call FUTEX_WAKE.  This results in one extra wake         * call whenever a lock is contended, but lets us avoid forgetting         * anyone without requiring us to track the number of sleepers.         *         * It's possible for another thread to sneak in and grab the lock         * between the zero assignment above and the wake call below.  If         * the new thread is "slow" and holds the lock for a while, we'll         * wake up a sleeper, which will swap in a 2 and then go back to         * sleep since the lock is still held.  If the new thread is "fast",         * running to completion before we call wake, the thread we         * eventually wake will find an unlocked mutex and will execute.         * Either way we have correct behavior and nobody is orphaned on         * the wait queue.         */        __futex_wake_ex(&mutex->value, shared, 1);//唤醒等待的    }} 

trylock

int pthread_mutex_trylock(pthread_mutex_t *mutex){    int mtype, tid, oldv, shared;    if (__unlikely(mutex == NULL))        return EINVAL;    mtype  = (mutex->value & MUTEX_TYPE_MASK);    shared = (mutex->value & MUTEX_SHARED_MASK);    /* Handle common case first */    if ( __likely(mtype == MUTEX_TYPE_NORMAL) )    {        if (__atomic_cmpxchg(shared|0, shared|1, &mutex->value) == 0) {            ANDROID_MEMBAR_FULL();            return 0;        }        return EBUSY;    }    /* Do we already own this recursive or error-check mutex ? */    tid = __get_thread()->kernel_id;    if ( tid == MUTEX_OWNER(mutex) )//当前thread已经持有mutex    {        int counter;        if (mtype == MUTEX_TYPE_ERRORCHECK) {            /* already locked by ourselves */            return EDEADLK;        }        //更新counter计数器        _recursive_lock();        oldv = mutex->value;        counter = (oldv + (1 << MUTEX_COUNTER_SHIFT)) & MUTEX_COUNTER_MASK;        mutex->value = (oldv & ~MUTEX_COUNTER_MASK) | counter;        _recursive_unlock();        return 0;    }    /* Restore sharing bit in mtype */    mtype |= shared;    /* Try to lock it, just once. */    _recursive_lock();    oldv = mutex->value;    if (oldv == mtype)  /* uncontended released lock => state 1 */        mutex->value = ((tid << 16) | mtype | 1);    _recursive_unlock();    if (oldv != mtype)        return EBUSY;    return 0;}

timeout

转载地址：http://mashb.baihongyu.com/