第15篇：多线程编程基础

HYP_Coder

已于 2024-09-15 07:36:04 修改

阅读量352

点赞数 13

分类专栏： C语言教程文章标签：开发语言 c语言

于 2024-09-15 07:03:13 首次发布

本文链接：https://blog.csdn.net/HYP_Coder/article/details/142269069

版权

C语言教程专栏收录该内容

15 篇文章 0 订阅

订阅专栏

多线程编程基础

在现代软件开发中，处理多任务和并发操作已成为一种常见需求。C语言虽然是一门相对低级的编程语言，但它提供了强大的多线程编程支持。了解多线程编程的基本概念及其应用，对于开发高效和响应迅速的应用程序非常重要。在这一篇中，我们将深入探讨线程的基本概念、线程的创建与管理、线程同步与互斥等内容。

15.1 线程的基本概念

15.1.1 什么是线程？

线程是程序中的一个执行单元，是进程内的一个子任务。线程共享进程的资源，包括内存和文件描述符，但每个线程有自己的栈、寄存器和程序计数器。通过使用多线程，程序可以并发执行多个任务，从而提高程序的响应能力和处理能力。

将线程的概念类比于日常生活中的场景，假设你正在经营一家餐馆。餐馆有多个服务员（线程），他们同时处理不同顾客的订单，但所有服务员都共享餐馆的厨房、菜单和座位等资源。每个服务员都有自己的工作任务（线程的执行单元），而厨房和其他资源是共享的（线程共享的资源）。

15.1.2 线程的创建与管理

在C语言中，线程的创建和管理通常依赖于POSIX线程库（pthreads）。这是一个在UNIX/Linux系统上广泛使用的标准线程库。

下面是使用POSIX线程库创建和管理线程的基本步骤：

包含头文件：在C语言程序中使用线程功能，需要包含pthread.h头文件。
c
```
#include <pthread.h>
```
定义线程函数：线程的入口函数是线程启动时执行的函数。它的返回类型是void*，接受一个void*类型的参数，并且可以返回一个void*类型的结果。
c
```
void* thread_function(void* arg) {
    // 线程执行的任务
    printf("Hello from the thread!\n");
    return NULL;
}
```
创建线程：使用pthread_create函数创建线程。这个函数接受四个参数：线程标识符、线程属性、线程函数以及传递给线程函数的参数。
c
```
pthread_t thread_id;
pthread_create(&thread_id, NULL, thread_function, NULL);
```
等待线程结束：使用pthread_join函数等待线程结束。这样可以确保主线程在子线程结束之前不会终止。
c
```
pthread_join(thread_id, NULL);
```
清理资源：线程结束后，系统会自动释放线程占用的资源，但在某些情况下，可能需要显式地进行资源清理。
c
```
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
```

15.1.3 线程的优势

使用线程的主要优势包括：

提高效率：多线程可以利用多核处理器的优势，同时进行多个任务，提高程序的效率。例如，在一个视频处理程序中，多个线程可以同时处理不同的视频帧，从而加快整个视频的处理速度。
增强响应能力：在UI应用程序中，多线程可以避免界面冻结，使得程序在执行复杂计算时仍然保持响应。例如，一个聊天应用程序可以在一个线程中处理消息的接收和发送，而在另一个线程中处理用户的界面操作。
简化设计：在一些应用中，使用线程可以使得程序设计更加简洁和模块化。例如，一个网络服务器可以使用线程来处理每一个客户端的请求，这样每个线程只需要关注一个客户端的处理逻辑。

15.2 线程同步与互斥

在多线程编程中，由于多个线程可能会访问共享资源，因此需要确保线程之间的操作不会导致数据的不一致性。为了达到这个目的，通常需要使用同步和互斥机制。

15.2.1 互斥量（Mutex）

互斥量（Mutex）是一种用于保护共享资源的同步机制。它确保同一时间只有一个线程能够访问被保护的资源，从而防止数据竞争和不一致性。

在POSIX线程库中，可以使用pthread_mutex_t类型定义互斥量，并通过pthread_mutex_init函数初始化互斥量，通过pthread_mutex_lock函数加锁，通过pthread_mutex_unlock函数解锁。

示例代码：

c

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

pthread_mutex_t mutex;

void* thread_function(void* arg) {
    pthread_mutex_lock(&mutex);
    // 访问共享资源
    printf("Thread is accessing shared resource\n");
    pthread_mutex_unlock(&mutex);
    return 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;
}

c

在这个示例中，mutex用于保护共享资源。pthread_mutex_lock和pthread_mutex_unlock分别用于加锁和解锁互斥量，确保同一时间只有一个线程可以访问共享资源。

15.2.2 条件变量（Condition Variable）

条件变量是一种用于线程间通信的机制。当一个线程需要等待某个条件满足时，它可以使用条件变量来暂停自己的执行，直到条件满足为止。条件变量通常与互斥量一起使用，以保证条件检查和等待过程的原子性。

在POSIX线程库中，可以使用pthread_cond_t类型定义条件变量，并通过pthread_cond_wait函数等待条件，通过pthread_cond_signal或pthread_cond_broadcast函数通知其他线程条件已经满足。

示例代码：

c

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

pthread_mutex_t mutex;
pthread_cond_t cond;
int shared_data = 0;

void* producer(void* arg) {
    pthread_mutex_lock(&mutex);
    shared_data = 1;
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);
    return NULL;
}

void* consumer(void* arg) {
    pthread_mutex_lock(&mutex);
    while (shared_data == 0) {
        pthread_cond_wait(&cond, &mutex);
    }
    printf("Consumer received data: %d\n", shared_data);
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main() {
    pthread_t producer_thread, consumer_thread;
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);

    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);

    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

c

在这个示例中，producer线程设置shared_data的值，并通过pthread_cond_signal通知consumer线程。consumer线程在条件满足之前使用pthread_cond_wait进行等待。

15.2.3 线程的同步与数据竞争

数据竞争发生在两个或多个线程同时访问共享数据，并且至少有一个线程在修改数据时。为了避免数据竞争，应该采取适当的同步措施。

使用互斥量（mutex）和条件变量（condition variable）是避免数据竞争的常用方法。互斥量确保同一时刻只有一个线程访问共享资源，而条件变量则用于在特定条件下通知其他线程继续执行。

15.2.4 线程的生命周期

线程的生命周期包括创建、执行和终止三个阶段。线程在创建时分配资源，在执行时运行指定的任务，在终止时释放资源。为了管理线程的生命周期，通常需要使用线程创建、同步和销毁等函数。

15.2.5 线程优先级

在一些操作系统中，线程的优先级可以影响线程的调度顺序。优先级高的线程通常会先于优先级低的线程获得处理器时间。然而，在POSIX线程库中，线程的优先级管理通常是操作系统特定的，具体的优先级设置和调整方法可能因操作系统而异。

15.2.6 实践中的多线程挑战

在实践中，使用多线程可能会遇到许多挑战，例如死锁、活锁和竞态条件等。为了避免这些问题，开发者需要仔细设计线程的同步机制，并使用适当的调试工具来检测和解决多线程中的问题。

15.3 高级线程编程

15.3.1 线程池

线程池是一种管理线程的技术，它预先创建一定数量的线程，并将任务提交给这些线程进行处理。线程池可以避免频繁创建和销毁线程的开销，提高系统的性能和响应速度。线程池的基本思想是将线程的创建和销毁交由线程池管理，从而提高线程的复用率。

示例代码：

c

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

#define THREAD_POOL_SIZE 4
#define TASK_QUEUE_SIZE 10

// 任务结构体
typedef struct {
    void (*function)(void* arg);
    void* arg;
} task_t;

// 线程池结构体
typedef struct {
    pthread_t threads[THREAD_POOL_SIZE];
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    task_t task_queue[TASK_QUEUE_SIZE];
    int task_count;
    int head;
    int tail;
    int shutdown;
} thread_pool_t;

// 线程池的工作函数
void* worker(void* arg) {
    thread_pool_t* pool = (thread_pool_t*)arg;
    while (1) {
        pthread_mutex_lock(&pool->mutex);

        while (pool->task_count == 0 && !pool->shutdown) {
            pthread_cond_wait(&pool->cond, &pool->mutex);
        }

        if (pool->shutdown) {
            pthread_mutex_unlock(&pool->mutex);
            pthread_exit(NULL);
        }

        task_t task = pool->task_queue[pool->head];
        pool->head = (pool->head + 1) % TASK_QUEUE_SIZE;
        pool->task_count--;

        pthread_mutex_unlock(&pool->mutex);

        task.function(task.arg);
    }
    pthread_exit(NULL);
}

// 初始化线程池
void thread_pool_init(thread_pool_t* pool) {
    pthread_mutex_init(&pool->mutex, NULL);
    pthread_cond_init(&pool->cond, NULL);
    pool->task_count = 0;
    pool->head = 0;
    pool->tail = 0;
    pool->shutdown = 0;

    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        pthread_create(&pool->threads[i], NULL, worker, pool);
    }
}

// 添加任务到线程池
void thread_pool_add_task(thread_pool_t* pool, void (*function)(void*), void* arg) {
    pthread_mutex_lock(&pool->mutex);

    if (pool->task_count < TASK_QUEUE_SIZE) {
        pool->task_queue[pool->tail].function = function;
        pool->task_queue[pool->tail].arg = arg;
        pool->tail = (pool->tail + 1) % TASK_QUEUE_SIZE;
        pool->task_count++;
        pthread_cond_signal(&pool->cond);
    }

    pthread_mutex_unlock(&pool->mutex);
}

// 关闭线程池
void thread_pool_shutdown(thread_pool_t* pool) {
    pthread_mutex_lock(&pool->mutex);
    pool->shutdown = 1;
    pthread_cond_broadcast(&pool->cond);
    pthread_mutex_unlock(&pool->mutex);

    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        pthread_join(pool->threads[i], NULL);
    }

    pthread_mutex_destroy(&pool->mutex);
    pthread_cond_destroy(&pool->cond);
}

// 任务示例
void example_task(void* arg) {
    int* num = (int*)arg;
    printf("Task is running with arg: %d\n", *num);
    free(num);
}

int main() {
    thread_pool_t pool;
    thread_pool_init(&pool);

    for (int i = 0; i < 10; i++) {
        int* num = malloc(sizeof(int));
        *num = i;
        thread_pool_add_task(&pool, example_task, num);
    }

    thread_pool_shutdown(&pool);
    return 0;
}

c

在这个示例中，我们定义了一个线程池结构体thread_pool_t，其中包含了线程池的线程、互斥量、条件变量、任务队列以及任务计数等信息。线程池通过thread_pool_init函数进行初始化，启动了一些工作线程。工作线程从任务队列中取出任务并执行。任务通过thread_pool_add_task函数添加到线程池中，并通过thread_pool_shutdown函数关闭线程池，等待所有线程结束并清理资源。

15.3.2 读写锁

读写锁是一种允许多个线程同时读取共享数据，但在写入数据时排斥所有读取和写入操作的锁。读写锁在读操作远多于写操作的场景中非常有用，可以提高系统的性能。

在POSIX线程库中，读写锁通过pthread_rwlock_t类型定义，并通过pthread_rwlock_init函数初始化。读取线程使用pthread_rwlock_rdlock获取读锁，写入线程使用pthread_rwlock_wrlock获取写锁，而释放锁则使用pthread_rwlock_unlock。

示例代码：

c

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

pthread_rwlock_t rwlock;
int shared_data = 0;

void* reader(void* arg) {
    pthread_rwlock_rdlock(&rwlock);
    printf("Reader read data: %d\n", shared_data);
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

void* writer(void* arg) {
    pthread_rwlock_wrlock(&rwlock);
    shared_data++;
    printf("Writer updated data to: %d\n", shared_data);
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

int main() {
    pthread_t readers[5], writers[3];
    pthread_rwlock_init(&rwlock, NULL);

    for (int i = 0; i < 5; i++) {
        pthread_create(&readers[i], NULL, reader, NULL);
    }
    for (int i = 0; i < 3; i++) {
        pthread_create(&writers[i], NULL, writer, NULL);
    }

    for (int i = 0; i < 5; i++) {
        pthread_join(readers[i], NULL);
    }
    for (int i = 0; i < 3; i++) {
        pthread_join(writers[i], NULL);
    }

    pthread_rwlock_destroy(&rwlock);
    return 0;
}

c

在这个示例中，rwlock用于控制对shared_data的访问。reader线程获取读锁并读取数据，而writer线程获取写锁并更新数据。通过读写锁，可以确保多个读取操作不会互相干扰，但在写操作期间，所有读取和写入操作都会被阻塞。

15.3.3 死锁与活锁

在多线程编程中，死锁和活锁是常见的同步问题。

死锁：当多个线程互相等待对方释放资源，从而形成一种循环等待的状态时，就会发生死锁。为了避免死锁，可以使用以下策略：
- 确保资源分配的顺序一致。
- 使用超时机制来检测和解决死锁。
- 避免持有锁时进行长时间的操作。
活锁：当线程之间不断地改变状态以避免死锁，但由于缺乏适当的同步机制，导致线程不能继续执行。为避免活锁，确保线程在执行状态变化时，能正确地恢复到可以继续执行的状态。

15.3.4 线程的调试

调试多线程程序可能会更加复杂，因为需要处理线程间的交互和同步问题。常用的调试技术包括：

日志记录：通过添加日志记录，跟踪线程的创建、执行和同步状态。
调试工具：使用线程调试工具（如gdb）来监控线程的状态和调试多线程程序。
死锁检测：使用工具或库来检测和解决死锁问题。

15.3.5 线程的性能优化

优化多线程程序的性能可以从以下几个方面入手：

减少锁的持有时间：尽量减少持有锁的时间，避免长时间的锁竞争。
使用锁的粒度：根据具体情况选择合适的锁粒度，避免过于细化或粗化的锁策略。
优化任务划分：合理划分任务，避免过多的线程切换和上下文切换开销。
线程数的合理配置：根据系统的CPU核心数和任务的特性，合理配置线程数。

通过以上方法，可以有效提高多线程程序的性能和稳定性。

总结

本篇文章涵盖了多线程编程的基本概念和技术，包括线程的创建与管理、同步与互斥、线程池、读写锁、死锁与活锁等内容。掌握这些基本知识，并能够运用到实际开发中，对于编写高效且可靠的多线程程序至关重要。在实际编程中，还需要结合具体应用场景，针对性能瓶颈和同步问题进行优化和调试。希望通过本文的学习，能帮助你更好地理解和应用多线程编程技术。