pthread 基础篇 互斥锁

一 互斥锁基本操作函数

//获取互斥所，阻塞式的，获取不到就死等

int pthread_mutex_lock(pthread_mutex_t *mutex); 

//尝试获取互斥锁，获取不到返回错误码，成功返回0

int pthread_mutex_trylock(pthread_mutex_t *mutex);

//解锁，成功返回0

int pthread_mutex_unlock(pthread_mutex_t *mutex); 

二 互斥锁的几种常用属性及用法

应该是出于程序健壮性和互斥锁执行效率的考虑，此出现以下到多种属性，

使用时根据具体情况加以选择

2.1 默认互斥锁类型

初始化 pthread_mutex_t类型变量为PTHREAD_MUTEX_INITIALIZER

特性：1 非加锁线程可以解锁（这个锁没有指纹识别功能，任何人有钥匙都能开~_~）

            2 线程嵌套调用锁，会产生死锁

2.2 适应锁

初始化 pthread_mutex_t类型变量为PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP

特性：与默认锁基本一直，唯一不同在于当产生嵌套锁时，标准描述为结果未定义

2.3 检错锁

初始化 pthread_mutex_t类型变量为PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP

特性：1 非加锁线程不可以解锁（这个锁有指纹识别功能，有钥匙没有上锁人的指纹是不能开地^_^）

            2 线程嵌套调用锁，再次尝试加锁，pthread_mutex_lock返回错误码，而不是死等，所以避免了简单到死锁

2.4 嵌套锁

特性：1 非加锁线程不可以解锁（这个锁有指纹识别功能，有钥匙没有上锁人的指纹是不能开地^_^）

            2 线程嵌套调用锁，再次尝试加锁，pthread_mutex_lock返回成功，内部有个计数，每lock一次就+1，每unlock一次就-1，当该计数为0时表示资源可用

三 解锁操作

当调用pthread_mutex_unlock后使资源再次可用时，会触发调度程序，决议谁将获取该锁

（不一定是当前线程哦，即使在unlock后执行lock^_^）

测试环境：ubuntu 12.04

测试代码：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define THREAD_NUM      3

#define USE_MUTEX
//#undef        USE_MUTEX

#define USE_MUTEX_NORMAL        0
#define USE_MUTEX_ERRCHECK      0
#define USE_MUTEX_RECU          1
#define USE_MUTEX_ADAPTIVE      0

#define USE_TRYLOCK             1

#define CASE_RECULOCK           1
#define CASE_UNLOCK_BY_UNLOCKER 1

#ifdef  USE_MUTEX

#if(USE_MUTEX_NORMAL)
pthread_mutex_t g_mutex_thread_count    = PTHREAD_MUTEX_INITIALIZER;
#elif(USE_MUTEX_ERRCHECK)
pthread_mutex_t g_mutex_thread_count    = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
#elif(USE_MUTEX_RECU)
pthread_mutex_t g_mutex_thread_count    = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
#else
pthread_mutex_t g_mutex_thread_count    = PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP;
#endif

#endif  //USE_MUTEX

int g_thread_count;


void increment_thread_count(unsigned thread_id)
{
#ifdef  USE_MUTEX
 #if(CASE_RECULOCK)
        int     iret    = 0;
        printf("thread %u lev 1 before call lock function\n", thread_id);
        iret    = pthread_mutex_lock(&g_mutex_thread_count);
        printf("thread %u lev 1 lock return value = %d\n", thread_id, iret);
        if(0 == iret)
        {   
                g_thread_count++;
                pthread_mutex_unlock(&g_mutex_thread_count);
        }   
 #endif //CASE_RECULOCK
#else   //USE_MUTEX

}

void *pthread_proc_function(void *arg)
{
        int     iret    = 0;
        char    str_thread_id[8]        = {0};
        printf("thread %u g_mutex_thread_count = %u\n", (unsigned)pthread_self(), g_thread_count);
#ifdef  USE_MUTEX
 #if(CASE_UNLOCK_BY_UNLOCKER)
        iret    = pthread_mutex_unlock(&g_mutex_thread_count);
        printf("thread %u unlock by unlocker return value = %d\n", (unsigned)pthread_self(), iret);
 #endif

 #if(USE_TRYLOCK)
        iret    = pthread_mutex_trylock(&g_mutex_thread_count);
        printf("thread %u lev0 trylock return value = %d\n", (unsigned)pthread_self(), iret);
 #else  //USE_TRYLOCK
        iret    = pthread_mutex_lock(&g_mutex_thread_count);
        printf("thread %u lev0 lock return value = %d\n", (unsigned)pthread_self(), iret);
 #endif //USE_TRYLOCK
        if(0 == iret)
        {
                increment_thread_count((unsigned)pthread_self());
                pthread_mutex_unlock(&g_mutex_thread_count);
        }
#else   //USE_MUTEX
        increment_thread_count((unsigned)pthread_self());
#endif  //USE_MUTEX
}

int main(int argc, char **argv)
{
        pthread_t       thread_id[THREAD_NUM];
        int     i = 0;

#if(USE_MUTEX_NORMAL)
        printf("use mutex normal\n");
#elif(USE_MUTEX_ERRCHECK)
        printf("use mutex error check\n");
#elif(USE_MUTEX_RECU)
        printf("use mutex recursive\n");
#elif(USE_MUTEX_ADAPTIVE)
        printf("use mutex adaptive\n");
#endif

#if(CASE_RECULOCK)
        printf("have recursive mutex lock\n");
#endif

#if(CASE_UNLOCK_BY_UNLOCKER)
        printf("have unlock by unlocker\n");
#endif

        for(i = 0; i < THREAD_NUM; i++)
        {
                pthread_create(&thread_id[i], NULL, pthread_proc_function, (void *)i);
        }

        for(i = 0; i < THREAD_NUM; i++)
        {
                pthread_join(thread_id[i], NULL);
        }

        printf("main thread total count: %u\n", g_thread_count);
        exit(0);
}

参考资料：

1· http://man.yolinux.com/cgi-bin/man2html?cgi_command=pthread_mutex_lock

2· http://hi.baidu.com/cunlin/item/c05a50fc7be34f19a62988af