C语言编写多线程，什么时候要使用互斥锁？为什么要使用互斥锁？

在多线程编程中，当多个线程同时访问共享资源（如变量、文件等）时，会出现竞态条件（Race Condition）问题，导致程序的行为不可预测。为了避免这种问题，需要使用互斥锁来保护共享资源的访问。

互斥锁是一种线程同步机制，它保证同一时刻只有一个线程可以访问共享资源，其他线程需要等待该线程释放锁才能继续访问。在C语言中，可以使用标准库提供的pthread_mutex_t结构体来实现互斥锁。

在哪些情况下需要使用互斥锁呢？一般来说，只有在多个线程同时访问共享资源时才需要使用互斥锁。以下是一些常见的情况：

1. 多个线程同时访问同一个全局变量或静态变量。
2. 多个线程同时访问同一个动态分配的内存块。
3. 多个线程同时访问同一个文件或网络套接字。
4. 多个线程同时访问同一个数据结构，如链表或树。

需要注意的是，过多地使用互斥锁可能会导致性能问题。因此，在使用互斥锁时，需要权衡程序的正确性和性能开销，尽可能减少锁的使用次数。

假设有两个线程 A 和 B，它们需要同时访问一个共享资源：一个全局变量 x。线程 A 需要读取 x 的值并将其加 1，线程 B 需要读取 x 的值并将其减 1。

如果不使用互斥锁，可能会出现以下情况：

1. 线程 A 读取 x 的值为 n，然后将其加 1，得到 n+1。
2. 在线程 A 执行完加 1 操作之前，线程 B 读取 x 的值为 n，然后将其减 1，得到 n-1。
3. 线程 A 将 n+1 写回到 x 中，x 的值变成了 n+1。
4. 线程 B 将 n-1 写回到 x 中，x 的值变成了 n-1，而不是原本的 n。

为了避免这种竞态条件问题，可以使用互斥锁来保护 x 的访问。具体地，在访问 x 的代码前加锁，在访问结束后释放锁。这样可以保证同一时刻只有一个线程可以访问 x，从而避免竞态条件问题。

下面是一个简单的C语言使用互斥锁保护全局变量的例子：

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;  // 定义互斥锁

int global_var = 0;

void *thread_func(void *arg) {
    int thread_num = *(int *)arg;
    int i;
    for (i = 0; i < 100000; i++) {
        pthread_mutex_lock(&mutex);  // 加锁
        global_var++;
        printf("Thread %d: global_var = %d\n", thread_num, global_var);
        pthread_mutex_unlock(&mutex);  // 解锁
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    int thread_num1 = 1, thread_num2 = 2;

    // 创建两个线程
    if (pthread_create(&thread1, NULL, thread_func, &thread_num1) != 0) {
        perror("pthread_create");
        exit(EXIT_FAILURE);
    }
    if (pthread_create(&thread2, NULL, thread_func, &thread_num2) != 0) {
        perror("pthread_create");
        exit(EXIT_FAILURE);
    }

    // 等待两个线程结束
    if (pthread_join(thread1, NULL) != 0) {
        perror("pthread_join");
        exit(EXIT_FAILURE);
    }
    if (pthread_join(thread2, NULL) != 0) {
        perror("pthread_join");
        exit(EXIT_FAILURE);
    }

    return 0;
}
           

在上面的代码中，我们定义了一个全局变量 global_var，然后创建了两个线程 thread1 和 thread2，它们会分别对 global_var 进行加 1 操作。在访问 global_var 的代码前，我们使用了 pthread_mutex_lock 函数来加锁，在访问结束后使用 pthread_mutex_unlock 函数来解锁，以保证同一时刻只有一个线程可以访问 global_var。