Linux线程：互斥锁mutex的使用

1. 同步 & 互斥

（1）同步

多个进程或线程按照一定的执行顺序完成某一任务；如B任务依赖A任务产生的数据。

（2）互斥

临界资源同一时刻只能被一个进程或线程使用。

---

2. 临界资源 和 临界区

（1）临界资源

一次只允许一个进程或线程访问的资源，互斥访问的资源。

（2）临界区

访问临界资源的代码段。多进程、多线程时，通常需要给临界区上锁。

---

3. 互斥锁mutex

临界区访问临界资源前加锁，对临界资源的操作完成后解锁；保证临界资源的互斥访问。

互斥锁相关函数

（1）互斥锁的初始化、销毁

#include

int pthread_mutex_init(pthread_mutex_t* restrict mutex, const pthread_mutexattr_t* restrict attr);
/*
功能：
    初始化互斥锁mutex
参数：
    mutex：互斥锁地址
    attr：用来设置互斥锁的属性；通常为NULL。
    
    可使用宏PTHREAD_MUTEX_INITIALIZER来静态初始化互斥锁，如：
        pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER，但此方法不会进行错误检查。
返回值：
    成功：0.
    失败：非0错误码。
*/

/* restrict关键字：表示指针所指的对象在指针的生命周期内不会被其他指针引用或修改；
                  以便让编译器更好地优化，避免不必要的内存访问或修改。    */

int pthread_mutex_destory(pthread_mutex_t* mutex);
/*
功能：
    销毁互斥锁mutex
参数：
    mutex：互斥锁的地址
返回值：
    成功：0
    失败：非0错误码
*/

（2）加、解锁（获取、释放锁）

#include

/* 加锁 */
int pthread_mutex_lock(pthread_mutex_t* mutex);
/*
功能：
    加互斥锁mutex。若已被加锁，则阻塞至可以加锁。
参数：
    mutex：互斥锁地址
返回值：
    成功：0
    失败：非0错误码
*/

int pthread_mutex_trylock(pthread_mutex_t* mutex);
/*
功能：
    以非阻塞的方式加锁。
返回值：
    若临界区未被加锁，则直接加锁，返回0；
    若临界区已被加锁，则直接返回EBUSY。
*/

/* 解锁 */
int pthread_mutex_unlock(pthread_mutex_t* mutex);
/*
功能：
    解互斥锁mutex
参数：
    mutex：互斥锁地址
返回值：
    成功：0
    失败：非0错误码
*/

---

4. 互斥锁简单使用示例

如2个线程想使用同一台打印机，一个线程想打印Hello，另一个想打印World：

（1）未使用无互斥锁的打印机

#include
#include
#include

void printer(char* str) { // 公共打印机
    while (*str != '\0') {
        putchar(*str);
        fflush(stdout); // 刷新输出缓冲区
        str++;
        usleep(1000);
    }
    putchar('\n');
}

void* task1(void* arg) { // 线程1的任务
    char* str = (char*)arg;
    printer(str);
    return NULL;
}

void* task2(void* arg) { // 线程2的任务
    char* str = (char*)arg;
    printer(str);
    return NULL;
}

int main(int argc, const char* argv[]) {

    pthread_t tid1, tid2;
    int ret = -1;

    char* str1 = "Hello";
    char* str2 = "World";

    ret = pthread_create(&tid1, NULL, task1, (void*)str1);
    if (0 != ret) {
        printf("线程1创建失败.\n");
        return 1;
    }

    ret = pthread_create(&tid2, NULL, task2, (void*)str2);
    if (0 != ret) {
        printf("线程2创建失败.\n");
        return 1;
    }

    ret = pthread_detach(tid1);
    if (0 != ret) {
        printf("线程1分离失败.\n");
        return 1;
    }

    ret = pthread_detach(tid2);
    if (0 != ret) {
        printf("线程2分离失败.\n");
        return 1;
    }
    sleep(1);

    return 0;
}

运行结果： 显然不符合预期。

（2）使用互斥锁的打印机

#include
#include
#include

/*互斥锁。
若定义为main函数中的局部变量，
则需要通过pthread_create函数的第四个参数传递互斥锁*/
pthread_mutex_t mutex;

void printer(char* str) {
    while (*str != '\0') {
        putchar(*str);
        fflush(stdout); // 刷新输出缓冲区
        str++;
        usleep(1000);
    }
    putchar('\n');
}

void* task1(void* arg) {
    char* str = (char*)arg;
    pthread_mutex_lock(&mutex);
    printer(str);
    pthread_mutex_unlock(&mutex);
    return NULL;
}

void* task2(void* arg) {
    char* str = (char*)arg;
    pthread_mutex_lock(&mutex);
    printer(str);
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main(int argc, const char* argv[]) {

    pthread_t tid1, tid2;
    int ret = -1;

    char* str1 = "Hello";
    char* str2 = "World";

    ret = pthread_mutex_init(&mutex, NULL); // 初始化互斥锁
    if (0 != ret) {
        printf("互斥锁初始化失败.\n");
        return 1;
    }
    printf("互斥锁已初始化.\n");

    ret = pthread_create(&tid1, NULL, task1, (void*)str1);
    if (0 != ret) {
        printf("线程1创建失败.\n");
        return 1;
    }

    ret = pthread_create(&tid2, NULL, task2, (void*)str2);
    if (0 != ret) {
        printf("线程2创建失败.\n");
        return 1;
    }

    ret = pthread_detach(tid1);
    if (0 != ret) {
        printf("线程1分离失败.\n");
        return 1;
    }

    ret = pthread_detach(tid2);
    if (0 != ret) {
        printf("线程2分离失败.\n");
        return 1;
    }
    sleep(1);

    // 销毁互斥锁。放在sleep之后，防止主线程执行过快，销毁了正在使用的互斥锁。
    ret = pthread_mutex_destroy(&mutex);
    if (0 != ret) {
        printf("互斥锁销毁失败.\n");
        return 1;
    }
    printf("互斥锁已销毁.\n");

    return 0;
}

运行结果：符合预期