C语言中怎样实现多线程 C语言多线程编程与同步机制介绍-C#.Net教程-PHP中文网

c语言实现多线程需借助操作系统线程库如pthread，1. 包含pthread.h等必要头文件；2. 定义符合void *function_name(void *arg)格式的线程函数；3. 使用pthread_create创建线程并传入参数；4. 通过pthread_join等待线程结束；5. 利用互斥锁、读写锁、信号量等机制实现线程同步；6. 编译时链接-lpthread库。避免数据竞争可通过1. 使用互斥锁保护共享资源；2. 使用读写锁优化读多写少场景；3. 使用原子操作保证简单变量的原子性；4. 减少共享状态；5. 使用线程安全数据结构。处理线程取消应1. 设置取消状态和类型为延迟取消；2. 插入取消点或调用pthread_testcancel；3. 使用清理处理程序释放资源；4. 避免异步取消。常见陷阱包括1. 数据竞争；2. 死锁；3. 活锁；4. 优先级反转；5. 资源泄漏；6. 伪共享；7. 线程安全问题；8. 过度同步；9. 忘记处理错误；10. 不正确的线程取消。选择同步机制依据场景考虑1. 互斥锁用于独占访问；2. 读写锁用于读多写少；3. 条件变量用于线程通信；4. 信号量控制资源访问数量；5. 原子操作用于简单变量；6. 自旋锁用于短时间等待；7. 屏障用于线程执行同步，并综合评估性能、复杂性、可扩展性和适用性。

C语言中怎样实现多线程 C语言多线程编程与同步机制介绍

C语言实现多线程，本质上是调用操作系统提供的线程库，比如POSIX线程库（pthread）。重点在于理解线程创建、同步与资源管理。

解决方案

C语言本身不直接支持多线程，需要借助操作系统提供的线程库。在Linux环境下，常用的就是POSIX线程库（pthread）。以下是实现多线程的基本步骤：

包含头文件： 首先，需要在代码中包含pthread.h头文件，这个头文件包含了所有关于pthread线程库的函数声明和数据结构定义。

立即学习“C语言免费学习笔记（深入）”；
```
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h> // 为了使用 exit()
```
登录后复制
创建线程函数： 定义一个函数，这个函数将作为线程的入口点。线程开始执行时，就会从这个函数开始执行。这个函数的签名必须是void *function_name(void *arg)，即接受一个void *类型的参数，并返回一个void *类型的值。
```
void *thread_function(void *arg) {
    int thread_id = *(int *)arg; // 获取线程ID
    printf("线程 %d 正在执行\n", thread_id);
    pthread_exit(NULL); // 线程退出
}
```
登录后复制

创建线程： 使用pthread_create()函数来创建一个新的线程。这个函数接受四个参数：

指向pthread_t类型变量的指针，用于存储新创建的线程的ID。
线程属性，通常设置为NULL表示使用默认属性。
线程函数，即上面定义的线程入口点函数。
传递给线程函数的参数。

pthread_t thread_id[NUM_THREADS];
int thread_args[NUM_THREADS];
for (int i = 0; i < NUM_THREADS; i++) {
    thread_args[i] = i;
    int result = pthread_create(&thread_id[i], NULL, thread_function, (void *)&thread_args[i]);
    if (result != 0) {
        perror("线程创建失败");
        exit(EXIT_FAILURE);
    }
    printf("创建线程 %d\n", i);
}

登录后复制

等待线程结束： 使用pthread_join()函数来等待线程结束。这个函数接受两个参数：
- 线程的ID。
- 一个指向void *类型变量的指针，用于存储线程的返回值。如果不需要返回值，可以设置为NULL。
```
for (int i = 0; i < NUM_THREADS; i++) {
    pthread_join(thread_id[i], NULL);
    printf("线程 %d 结束\n", i);
}
```
登录后复制
线程同步： 多个线程访问共享资源时，需要进行同步，以避免出现数据竞争等问题。常用的同步机制包括互斥锁（mutex）、条件变量（condition variable）和信号量（semaphore）。
- 互斥锁： 用于保护共享资源，确保同一时间只有一个线程可以访问该资源。
- 条件变量： 用于线程间的通信，允许线程在特定条件下等待，直到另一个线程发出信号。
- 信号量： 用于控制对共享资源的访问数量。
编译和链接： 编译时需要链接pthread库。例如，在使用gcc编译器时，需要添加-lpthread选项。
```
gcc your_program.c -o your_program -lpthread
```
登录后复制

如何避免C语言多线程中的数据竞争？

数据竞争是指多个线程并发访问共享数据，并且至少有一个线程尝试修改数据，而没有采取适当的同步措施。避免数据竞争的关键在于理解并正确使用同步机制。以下是一些策略：

使用互斥锁（Mutexes）： 互斥锁是最常用的同步机制。通过互斥锁，可以保证在任何给定时刻，只有一个线程可以访问共享资源。

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

pthread_mutex_t mutex;
int shared_data = 0;

void *thread_function(void *arg) {
    pthread_mutex_lock(&mutex); // 加锁
    shared_data++;
    printf("线程: %ld, shared_data: %d\n", pthread_self(), shared_data);
    pthread_mutex_unlock(&mutex); // 解锁
    pthread_exit(NULL);
}

int main() {
    pthread_t thread1, thread2;
    pthread_mutex_init(&mutex, NULL); // 初始化互斥锁

    pthread_create(&thread1, NULL, thread_function, NULL);
    pthread_create(&thread2, NULL, thread_function, NULL);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    pthread_mutex_destroy(&mutex); // 销毁互斥锁
    return 0;
}

登录后复制

使用读写锁（Read-Write Locks）： 如果共享资源被频繁读取但很少被修改，可以使用读写锁。读写锁允许多个线程同时读取共享资源，但只允许一个线程写入。

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

pthread_rwlock_t rwlock;
int shared_data = 0;

void *reader_function(void *arg) {
    pthread_rwlock_rdlock(&rwlock); // 获取读锁
    printf("读者线程: %ld, shared_data: %d\n", pthread_self(), shared_data);
    pthread_rwlock_unlock(&rwlock); // 释放读锁
    pthread_exit(NULL);
}

void *writer_function(void *arg) {
    pthread_rwlock_wrlock(&rwlock); // 获取写锁
    shared_data++;
    printf("写者线程: %ld, shared_data: %d\n", pthread_self(), shared_data);
    pthread_rwlock_unlock(&rwlock); // 释放写锁
    pthread_exit(NULL);
}

int main() {
    pthread_t reader1, reader2, writer;
    pthread_rwlock_init(&rwlock, NULL); // 初始化读写锁

    pthread_create(&reader1, NULL, reader_function, NULL);
    pthread_create(&reader2, NULL, reader_function, NULL);
    pthread_create(&writer, NULL, writer_function, NULL);

    pthread_join(reader1, NULL);
    pthread_join(reader2, NULL);
    pthread_join(writer, NULL);

    pthread_rwlock_destroy(&rwlock); // 销毁读写锁
    return 0;
}

登录后复制

使用原子操作（Atomic Operations）： 对于简单的计数器或标志位等操作，可以使用原子操作。原子操作是不可中断的操作，可以保证在多线程环境下的正确性。

#include <pthread.h>
#include <stdio.h>
#include <stdatomic.h> // C11引入的原子操作头文件

atomic_int shared_counter = 0;

void *thread_function(void *arg) {
    for (int i = 0; i < 100000; i++) {
        atomic_fetch_add(&shared_counter, 1); // 原子加操作
    }
    pthread_exit(NULL);
}

int main() {
    pthread_t thread1, thread2;

    pthread_create(&thread1, NULL, thread_function, NULL);
    pthread_create(&thread2, NULL, thread_function, NULL);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    printf("shared_counter: %d\n", shared_counter);
    return 0;
}

登录后复制

避免共享状态： 尽可能地减少线程之间的共享状态。如果线程不需要访问共享数据，那么就不会出现数据竞争的问题。
使用线程安全的数据结构： 有些数据结构是线程安全的，可以在多线程环境下直接使用，而不需要额外的同步措施。例如，并发队列等。

C语言多线程中，如何优雅地处理线程取消？

线程取消是指一个线程请求另一个线程终止其执行。在C语言中使用pthread库时，可以通过pthread_cancel()函数来请求取消一个线程。然而，简单粗暴地取消线程可能会导致资源泄漏或其他问题。因此，需要一种优雅的方式来处理线程取消。

设置取消状态和类型： 线程可以通过pthread_setcancelstate()和pthread_setcanceltype()函数来设置自己的取消状态和类型。
- pthread_setcancelstate()函数用于设置线程的取消状态，可以设置为PTHREAD_CANCEL_ENABLE（允许取消）或PTHREAD_CANCEL_DISABLE（禁止取消）。
- pthread_setcanceltype()函数用于设置线程的取消类型，可以设置为PTHREAD_CANCEL_DEFERRED（延迟取消）或PTHREAD_CANCEL_ASYNCHRONOUS（异步取消）。
延迟取消意味着线程只会在取消点（cancellation point）被取消。取消点是一些特定的函数调用，例如pthread_testcancel()、pthread_join()、pthread_cond_wait()等。异步取消意味着线程可以在任何时候被取消，但这可能会导致资源泄漏或其他问题，因此不建议使用。
```
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

void *thread_function(void *arg) {
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); // 允许取消
    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL); // 设置为延迟取消

    while (1) {
        printf("线程正在执行\n");
        sleep(1);
        pthread_testcancel(); // 取消点
    }

    pthread_exit(NULL);
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_function, NULL);
    sleep(3);
    pthread_cancel(thread); // 请求取消线程
    pthread_join(thread, NULL);
    printf("线程已取消\n");
    return 0;
}
```
登录后复制

使用清理处理程序（Cleanup Handlers）： 清理处理程序是在线程被取消时执行的一段代码，用于释放资源、恢复状态等。可以使用pthread_cleanup_push()和pthread_cleanup_pop()函数来注册和注销清理处理程序。

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

void cleanup_handler(void *arg) {
    printf("执行清理处理程序\n");
    free(arg); // 释放资源
}

void *thread_function(void *arg) {
    int *data = malloc(sizeof(int));
    pthread_cleanup_push(cleanup_handler, data); // 注册清理处理程序

    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);

    while (1) {
        printf("线程正在执行\n");
        sleep(1);
        pthread_testcancel();
    }

    pthread_cleanup_pop(1); // 注销清理处理程序，并执行
    pthread_exit(NULL);
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_function, NULL);
    sleep(3);
    pthread_cancel(thread);
    pthread_join(thread, NULL);
    printf("线程已取消\n");
    return 0;
}

登录后复制

避免异步取消： 尽量避免使用异步取消，因为它可能会导致资源泄漏或其他问题。如果必须使用异步取消，需要非常小心地处理资源管理。
检查返回值： 在调用pthread库函数时，应该检查返回值，以确保函数调用成功。如果函数调用失败，应该采取适当的措施来处理错误。

C语言多线程编程的常见陷阱有哪些？

C语言多线程编程虽然强大，但也充满了陷阱，稍不注意就可能导致程序崩溃、数据错误或性能下降。

数据竞争（Data Races）： 多个线程同时访问和修改共享数据，而没有进行适当的同步，导致数据不一致。
- 解决方法： 使用互斥锁、读写锁、原子操作等同步机制来保护共享数据。
死锁（Deadlock）： 多个线程互相等待对方释放资源，导致所有线程都无法继续执行。
- 解决方法： 避免循环等待，按照固定的顺序获取锁，使用超时机制等。
活锁（Livelock）： 多个线程不断地重试相同的操作，但由于某些条件限制，导致所有线程都无法取得进展。
- 解决方法： 引入随机性，例如在重试之前等待一个随机的时间。
优先级反转（Priority Inversion）： 一个低优先级线程持有一个高优先级线程需要的锁，导致高优先级线程被阻塞。
- 解决方法： 使用优先级继承或优先级天花板协议。
资源泄漏（Resource Leaks）： 线程在退出时没有释放占用的资源，导致资源泄漏。
- 解决方法： 使用清理处理程序来释放资源，确保在线程退出时所有资源都被释放。
伪共享（False Sharing）： 多个线程访问不同的数据，但这些数据位于同一个缓存行中，导致缓存失效，影响性能。
- 解决方法： 填充缓存行，使不同的数据位于不同的缓存行中。
线程安全问题： 某些函数或数据结构不是线程安全的，在多线程环境下使用可能会导致问题。
- 解决方法： 使用线程安全的函数和数据结构，或者使用同步机制来保护非线程安全的函数和数据结构。
过度同步： 过度使用同步机制可能会导致性能下降，甚至死锁。
- 解决方法： 仔细分析代码，只在必要的地方使用同步机制。
忘记处理错误： pthread库函数可能会返回错误码，如果忘记处理错误，可能会导致程序崩溃。
- 解决方法： 检查pthread库函数的返回值，并采取适当的措施来处理错误。
不正确的线程取消： 粗暴地取消线程可能会导致资源泄漏或其他问题。
- 解决方法： 使用延迟取消和清理处理程序来优雅地处理线程取消。

如何选择合适的C语言多线程同步机制？

选择合适的同步机制取决于具体的应用场景和需求。以下是一些常用的同步机制及其适用场景：

互斥锁（Mutex）： 适用于保护共享资源，确保同一时间只有一个线程可以访问该资源。
- 适用场景： 对共享变量的读写操作、访问共享数据结构等。
读写锁（Read-Write Lock）： 适用于读多写少的场景，允许多个线程同时读取共享资源，但只允许一个线程写入。
- 适用场景： 读取配置文件、缓存数据等。
条件变量（Condition Variable）： 适用于线程间的通信，允许线程在特定条件下等待，直到另一个线程发出信号。
- 适用场景： 生产者-消费者模型、线程池等。
信号量（Semaphore）： 适用于控制对共享资源的访问数量。
- 适用场景： 限制同时访问数据库的连接数、控制并发执行的任务数等。
原子操作（Atomic Operations）： 适用于简单的计数器或标志位等操作，可以保证在多线程环境下的正确性。
- 适用场景： 原子计数器、原子标志位等。
自旋锁（Spin Lock）： 适用于锁的持有时间非常短的场景，线程会不断地尝试获取锁，而不是进入睡眠状态。
- 适用场景： 对性能要求非常高的场景，例如操作系统内核。
屏障（Barrier）： 适用于多个线程需要同步执行的场景，所有线程必须到达屏障点才能继续执行。
- 适用场景： 并行计算、图像处理等。