Linux C 编程——互斥锁mutex

1、多线程的问题引入

多线程的最大的特点是资源的共享，但是，当多个线程同时去操作（同时去改变）一个临界资源时，会破坏临界资源。如利用多线程同时写一个文件：

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

const char filename[] = "hello";

void* thread(void *id){

        int num = *(int *)id;

        // 写文件的操作
        FILE *fp = fopen(filename, "a+");
        int start = *((int *)id);
        int end = start + 1;
        setbuf(fp, NULL);// 设置缓冲区的大小
        fprintf(stdout, "%d\n", start);
        for (int i = (start * 10); i < (end * 10); i ++){
                fprintf(fp, "%d\t", i);
        }
        fprintf(fp, "\n");
        fclose(fp);

        return NULL;
}

int main(){
        int num_thread = 5;
        pthread_t *pt = (pthread_t *)malloc(sizeof(pthread_t) * num_thread);
        int * id = (int *)malloc(sizeof(int) * num_thread);

        for (int i = 0; i < num_thread; i++){
                id[i] = i;
                if (pthread_create(&pt[i], NULL, thread, &id[i]) != 0){
                        printf("thread create failed!\n");
                        return 1;
                }
        }
        for (int i = 0; i < num_thread; i++){
                pthread_join(pt[i], NULL);
        }

        // 释放资源
        free(pt);
        free(id);
        return 0;
}

执行以上的代码，我们会发现，得到的结果是混乱的，出现上述的最主要的原因是，我们在编写多线程代码的过程中，每一个线程都尝试去写同一个文件，这样便出现了上述的问题，这便是共享资源的同步问题，在Linux编程中，线程同步的处理方法包括：信号量，互斥锁和条件变量。

2、互斥锁

互斥锁是通过锁的机制来实现线程间的同步问题。互斥锁的基本流程为：

• 初始化一个互斥锁：pthread_mutex_init()函数
• 加锁：pthread_mutex_lock()函数或者pthread_mutex_trylock()函数
• 对共享资源的操作
• 解锁：pthread_mutex_unlock()函数
• 注销互斥锁：pthread_mutex_destory()函数

其中，在加锁过程中，pthread_mutex_lock()函数和pthread_mutex_trylock()函数的过程略有不同：

• 当使用pthread_mutex_lock()函数进行加锁时，若此时已经被锁，则尝试加锁的线程会被阻塞，直到互斥锁被其他线程释放，当pthread_mutex_lock()函数有返回值时，说明加锁成功；
• 而使用pthread_mutex_trylock()函数进行加锁时，若此时已经被锁，则会返回EBUSY的错误码。

同时，解锁的过程中，也需要满足两个条件：

• 解锁前，互斥锁必须处于锁定状态；
• 必须由加锁的线程进行解锁。

当互斥锁使用完成后，必须进行清除。

有了以上的准备，我们重新实现上述的多线程写操作，其实现代码如下所示：

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

pthread_mutex_t mutex;

const char filename[] = "hello";

void* thread(void *id){

        int num = *(int *)id;
        // 加锁

        if (pthread_mutex_lock(&mutex) != 0){
                fprintf(stdout, "lock error!\n");
        }
        // 写文件的操作
        FILE *fp = fopen(filename, "a+");
        int start = *((int *)id);
        int end = start + 1;
        setbuf(fp, NULL);// 设置缓冲区的大小
        fprintf(stdout, "%d\n", start);
        for (int i = (start * 10); i < (end * 10); i ++){
                fprintf(fp, "%d\t", i);
        }
        fprintf(fp, "\n");
        fclose(fp);

        // 解锁
        pthread_mutex_unlock(&mutex);

        return NULL;
}

int main(){
        int num_thread = 5;
        pthread_t *pt = (pthread_t *)malloc(sizeof(pthread_t) * num_thread);
        int * id = (int *)malloc(sizeof(int) * num_thread);

        // 初始化互斥锁
        if (pthread_mutex_init(&mutex, NULL) != 0){
                // 互斥锁初始化失败
                free(pt);
                free(id);
                return 1;
        }

        for (int i = 0; i < num_thread; i++){
                id[i] = i;
                if (pthread_create(&pt[i], NULL, thread, &id[i]) != 0){
                        printf("thread create failed!\n");
                        return 1;
                }
        }
        for (int i = 0; i < num_thread; i++){
                pthread_join(pt[i], NULL);
        }
        pthread_mutex_destroy(&mutex);

        // 释放资源
        free(pt);
        free(id);
        return 0;
}

最终的结果为：