linux互斥锁：递归锁，非递归锁用法详解

        在实际的项目中经常涉及到共享资源，共享资源被多个线程访问会出现竞争现象；为了解决竞争和保护共享资源常用的机制之一就是互斥锁！

        互斥锁又分为递归锁和非递归锁，互斥锁默认是非递归锁，也是我们常用的上锁方式。那么什么是递归锁和非递归锁呢？

非递归锁（Non-recursive Lock）

        使用方式：非递归锁每次只能被同一个线程加锁一次，若再次尝试加锁会导致死锁。所以在使用非递归锁时，应确保同一个线程不会重复加锁。

        返回值：非递归锁的锁操作函数pthread_mutex_lock和pthread_mutex_trylock返回0表示加锁成功，非0则表示加锁失败。

示例代码：

pthread_mutex_t mutex;

void* func(void){
        pthread_mutex_lock(&mutex);
//        pthread_mutex_lock(&mutex);//上锁之后再申请锁，这样会造成死锁
        std::cout<<"thread : "<<pthread_self()<<" going to get lock 2st"<<std::endl;
//        pthread_mutex_unlock(&mutex);
        pthread_mutex_unlock(&mutex);
        return NULL;
}

int main(void)
{
    int ret = 0;
    pthread_t p;

    pthread_mutex_init(&mutex, NULL);//初始化互斥锁
    
    if((ret = pthread_create(&p, NULL, func, NULL)) != 0){
        fprintf(stderr, "create thread error. msg:%s", strerror(ret));
        exit(1);
    }

    return 0;
}

        注意：非递归锁在同一个线程中只允许申请一把锁，申请的锁被释放后才能继续申请；如果非递归锁已经被占用还没有解锁就继续申请非递归锁就会造成死锁现象。

递归锁（Recursive Lock）

        使用方式：递归锁允许同一个线程多次对锁进行加锁，只有在多次解锁之后才能真正释放锁。使用递归锁时，同一个线程重复加锁不会导致死锁。

        返回值：递归锁的锁操作函数pthread_mutex_lock和pthread_mutex_trylock返回0表示加锁成功，非0则表示加锁失败。

        示例代码：

pthread_mutex_t mutex;
pthread_mutexattr_t attr;

void* func(void){
        pthread_mutex_lock(&mutex);
        pthread_mutex_lock(&mutex);//可以申请多个锁不会造成死锁
        std::cout<<"thread : "<<pthread_self()<<" going to get lock 2st"<<std::endl;
        pthread_mutex_unlock(&mutex);
        pthread_mutex_unlock(&mutex);
        return NULL;
}

int main(void)
{
    int ret = 0;
    pthread_t p;

    if(( ret = pthread_mutexattr_init(&attr)) != 0){
        fprintf(stderr, "create mutex attribute error. msg:%s", strerror(ret));
        exit(1);
    }
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    pthread_mutex_init(&mutex, &attr);

    if((ret = pthread_create(&p, NULL, func, NULL)) != 0){
        fprintf(stderr, "create thread error. msg:%s", strerror(ret));
        exit(1);
    }

    return 0;
}

        注意：想要使用递归锁需要使用pthread_mutexattr_t 结构进行显式的属性设置，递归锁在一个线程中可以申请多把锁，但是申请锁就需要对应的释放多少锁。只有完全释放递归锁，才能被别的线程申请。

        所以，既然递归锁这么麻烦，又容易造成死锁为什么还会出现递归锁呢？

        首先明确递归锁的应用场景：嵌套函数调用，递归算法，代码重构和复用等。

        以递归函数为例：

int buf[5] = {1,2,3,4,5};

void func(int val)
{
        if(val >= 5)
                return;

        pthread_mutex_lock(&mutex);
        func(buf[val++]);
        pthread_mutex_unlock(&mutex);

        //其他线程处理模块

        return;
}

int main(void) {

        func(0);

        return 0;
}

        假设buf为共享资源，要对buf进行上锁是必然的，但是在递归函数中上锁如果使用非递归锁就会造成死锁，所以一般嵌套函数或者递归算法会使用递归锁进行临界区的保护。注意使用递归锁必须依次释放所有的锁不然会造成死锁。

        那么问题来了：那为什么不在递归算法外部：func(0)前后加锁，解锁呢？

        当然这样也可以；不过如果嵌套函数或递归算法中除了共享资源外还有其他处理，那么在最外部调用可能会延长解锁时间，导致程序效率降低；所以不同的锁要根据使用的场景决定到底使用什么锁。