linux多线程之互斥锁

傷城~ 2022-09-25 05:18 329阅读 0赞

**基本概念：**

互斥变量是用pthread\_mutex\_t数据类型表示的。在使用互斥变量以前，必须首先对它进行初始化，可以把它设置为常量PTHREAD\_MUTEX\_INITIALIZER(只适用于静态分配的互斥量)，也可以通过调用pthread\_mutex\_init函数进行初始化。如果动态分配互斥量（例如，通过调用malloc函数），在释放内存前需要调用pthread\_mutex\_destroy。

**一、锁的初始化与销毁**

PTHREAD_MUTEX_DESTROY(P)   POSIX Programmer's Manual  PTHREAD_MUTEX_DESTROY(P)
    
    NAME
           pthread_mutex_destroy,  pthread_mutex_init  -  destroy and initialize a
           mutex
    
    SYNOPSIS
           #include <pthread.h>
    
           int pthread_mutex_destroy(pthread_mutex_t *mutex);
           int pthread_mutex_init(pthread_mutex_t *restrict mutex,
                  const pthread_mutexattr_t *restrict attr);
           pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

**两个函数的返回值：若成功，返回0；否则，返回错误码**

**二、加锁解锁**

PTHREAD_MUTEX_LOCK(P)                                    POSIX Programmer's Manual                                    PTHREAD_MUTEX_LOCK(P)
    
    NAME
           pthread_mutex_lock, pthread_mutex_trylock, pthread_mutex_unlock - lock and unlock a mutex
    
    SYNOPSIS
           #include <pthread.h>
    
           int pthread_mutex_lock(pthread_mutex_t *mutex);
           int pthread_mutex_trylock(pthread_mutex_t *mutex);
           int pthread_mutex_unlock(pthread_mutex_t *mutex);

**所有函数的返回值：若成功，返回0；否则返回错误码**

如果线程不希望被阻塞，它可以使用pthread\_mutex\_trylock尝试对互斥量进行加锁。如果调用pthread\_mutex\_trylock时互斥量处于未锁住状态，那么pthread\_mutex\_trylock将锁住互斥量，不会出现阻塞直接返回0，否则pthread\_mutex\_trylock就会失败，不能锁住互斥量，返回EBUSY.

**三、支持超时的阻塞lock**

PTHREAD_MUTEX_TIMEDLOCK(P)                               POSIX Programmer's Manual                               PTHREAD_MUTEX_TIMEDLOCK(P)
    
    NAME
           pthread_mutex_timedlock - lock a mutex (ADVANCED REALTIME)
    
    SYNOPSIS
           #include <pthread.h>
           #include <time.h>
    
           int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex,
                  const struct timespec *restrict abs_timeout);

**返回值：若成功，返回0；否则，返回错误码编号**

当线程试图获取一个已加锁的互斥量时，pthread\_mutex\_timedlock函数在达到超时时间值时，不会对互斥量进行加锁，而是返回错误码ETIMEDOUT

**四、互斥量属性**

PTHREAD_MUTEXATTR_DESTROY(P)                             POSIX Programmer's Manual                             PTHREAD_MUTEXATTR_DESTROY(P)
    
    NAME
           pthread_mutexattr_destroy, pthread_mutexattr_init - destroy and initialize the mutex attributes object
    
    SYNOPSIS
           #include <pthread.h>
    
           int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
           int pthread_mutexattr_init(pthread_mutexattr_t *attr);

**两个函数的返回值：若成功，返回0；否则，返回错误码编号**

互斥量属性是用pthread\_mutexattr\_t结构表示的。对于非默认属性，可以用pthread\_mutexattr\_init初始化pthread\_mutexattr\_t结构，用pthread\_mutexattr\_destroy来反初始化。pthread\_mutexattr\_init函数将用默认的互斥量属性初始化pthread\_mutexattr\_t结构。

值得注意的3个属性是：

1.进程共享属性：如果进程共享互斥量属性设置为PTHREAD\_PROCESS\_SHARED，从多个进程彼此之间共享的内存数据块中分配的互斥量就可以用于这些进程的同步。

2.健壮属性：互斥量健壮属性与在多个进程共享的互斥量有关

3.类型属性：类型互斥量属性控制着互斥量的锁定特性，可以用pthread\_mutexattr\_gettype函数得到互斥量类型属性，用pthread\_mutexattr\_settype函数修改互斥量类型属性。

**例子1，静态分配互斥量：gcc pthread\_mutex.c -pthread**

#include <pthread.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <errno.h>
    
    static int num = 0;
    static int count = 100000;
    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    
    void Perror(const char *s)
    {
        perror(s);
        exit(EXIT_FAILURE);
    }
    
    void* fun2(void *arg)
    {
        pthread_t thread_id = pthread_self();
        printf("the thread2 id is %ld\n", (long)thread_id);
        
        // ++
        int i = 1;
        for (; i<=count; ++i) {
            pthread_mutex_lock(&mutex);
            num += 1;
            pthread_mutex_unlock(&mutex);
        }
    }
    
    int main()
    {
        int err;
        pthread_t thread1;
        pthread_t thread2;
    
        thread1 = pthread_self();
        printf("the thread1 id is %ld\n", (long)thread1);
    
        // create thread
        err = pthread_create(&thread2, NULL, fun2, NULL);
        if (err != 0) {
            Perror("can't create thread2\n");
        }
    
        // detach thread3
        err = pthread_detach(thread2);
        if (err != 0) {
            Perror("can't detach thread2\n");
        }
    
        // ++
        int i = 1;
        for (; i<=count; ++i) {
            pthread_mutex_lock(&mutex);
            num += 1;
            pthread_mutex_unlock(&mutex);
        }
    
        sleep(10);
        printf("The num is %d\n", num);
    
        return 0;
    }

**例子2，动态分配互斥量：gcc pthread\_mutex.c -pthread**

#include <pthread.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <errno.h>
    
    static int num = 0;
    static int count = 100000;
    static pthread_mutex_t* pmutex;
    
    
    void Perror(const char *s)
    {
        perror(s);
        exit(EXIT_FAILURE);
    }
    
    void* fun2(void *arg)
    {
        pthread_t thread_id = pthread_self();
        printf("the thread2 id is %ld\n", (long)thread_id);
        int i = 1;
        for (; i<=count; ++i) {
            pthread_mutex_lock(pmutex);
            num += 1;
            pthread_mutex_unlock(pmutex);
        }
    }
    
    int main()
    {
        int err;
        pthread_t thread1;
        pthread_t thread2;
    
        // init mutex
        pmutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
        if (pthread_mutex_init(pmutex, NULL) != 0)
            Perror("pthread_mutex_init failed");
    
        thread1 = pthread_self();
        printf("the thread1 id is %ld\n", (long)thread1);
    
        // Create thread
        err = pthread_create(&thread2, NULL, fun2, NULL);
        if (err != 0) {
            Perror("can't create thread2\n");
        }
    
        // detach thread3
        err = pthread_detach(thread2);
        if (err != 0) {
            Perror("can't detach thread2\n");
        }
    
        int i = 1;
        for (; i<=count; ++i) {
            pthread_mutex_lock(pmutex);
            num += 1;
            pthread_mutex_unlock(pmutex);
        }
    
        sleep(10);
        printf("The num is %d\n", num);
    
        // destroy
        pthread_mutex_destroy(pmutex);
        free(pmutex);
    
        return 0;
    }

**ps:多进程间的互斥锁不在本文讨论范围，避免死锁可参考文章：[互斥量避免死锁][Link 1]**

参考：《unix环境高级编程》·第三版

End;

[Link 1]: http://blog.csdn.net/daiyudong2020/article/details/50709133