Linux系统编程：多线程与同步

Dev-Kilig

已于 2025-02-11 23:28:21 修改

阅读量620

点赞数 24

分类专栏： Linux 文章标签： linux

于 2025-02-11 23:20:04 首次发布

本文链接：https://blog.youkuaiyun.com/qq_63520660/article/details/145581736

版权

Linux 专栏收录该内容

3 篇文章

订阅专栏

引言

在现代操作系统中，多线程编程是提高程序并发性和性能的重要手段。Linux系统提供了强大的多线程支持，通过POSIX线程（pthread）库可以实现多线程编程。然而，多线程编程也带来了数据竞争和同步问题。本文将详细介绍多线程编程的基本概念，以及如何使用互斥锁和条件变量进行线程同步，并通过C语言代码示例帮助初学者理解。

1. 多线程编程的基本概念

1.1 什么是线程？

线程是操作系统调度的最小单位，是进程中的一个执行流。一个进程可以包含多个线程，这些线程共享进程的内存空间和资源。

进程 vs 线程：
- 进程是资源分配的单位，线程是CPU调度的单位。
- 线程比进程更轻量，创建和切换的开销更小。
- 线程共享进程的内存空间，而进程之间是隔离的。

1.2 多线程的优势

并发性：多线程可以同时执行多个任务，提高程序的响应速度。
资源共享：线程共享进程的内存空间，便于数据共享和通信。
性能提升：在多核CPU上，多线程可以充分利用硬件资源。

1.3 多线程的挑战

数据竞争：多个线程同时访问共享资源时，可能导致数据不一致。
死锁：多个线程相互等待资源，导致程序无法继续执行。
同步问题：需要确保线程之间的执行顺序和资源共享的安全性。

2. POSIX线程库（pthread）

POSIX线程库（pthread）是Linux系统中用于多线程编程的标准库。它提供了一系列函数用于创建、管理和同步线程。

2.1 创建线程

使用pthread_create()函数创建线程：

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine) (void *), void *arg);

thread：指向线程标识符的指针。
attr：线程属性，通常为NULL。
start_routine：线程执行的函数。
arg：传递给线程函数的参数。

2.2 终止线程

线程可以通过以下方式终止：

从线程函数中返回。
调用pthread_exit()函数。
被其他线程取消。

2.3 等待线程结束

使用pthread_join()函数等待线程结束：

int pthread_join(pthread_t thread, void **retval);

thread：要等待的线程标识符。
retval：存储线程返回值的指针。

3. 线程同步

3.1 互斥锁（Mutex）

互斥锁用于保护共享资源，确保同一时间只有一个线程可以访问。

3.1.1 创建和销毁互斥锁

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 静态初始化
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); // 动态初始化
int pthread_mutex_destroy(pthread_mutex_t *mutex); // 销毁互斥锁

3.1.2 加锁和解锁

int pthread_mutex_lock(pthread_mutex_t *mutex); // 加锁
int pthread_mutex_unlock(pthread_mutex_t *mutex); // 解锁

3.2 条件变量（Condition Variable）

条件变量用于线程间的通信，允许线程在某些条件满足时继续执行。

3.2.1 创建和销毁条件变量

pthread_cond_t cond = PTHREAD_COND_INITIALIZER; // 静态初始化
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr); // 动态初始化
int pthread_cond_destroy(pthread_cond_t *cond); // 销毁条件变量

3.2.2 等待和通知

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); // 等待条件
int pthread_cond_signal(pthread_cond_t *cond); // 通知一个等待线程
int pthread_cond_broadcast(pthread_cond_t *cond); // 通知所有等待线程

4. 示例：用C语言实现一个多线程程序

以下代码演示了如何使用互斥锁和条件变量实现一个简单的生产者-消费者模型。

4.1 代码实现

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

#define BUFFER_SIZE 10

int buffer[BUFFER_SIZE];
int count = 0; // 缓冲区中的数据数量

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_full = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_empty = PTHREAD_COND_INITIALIZER;

// 生产者线程函数
void* producer(void* arg) {
    for (int i = 0; i < 20; i++) {
        pthread_mutex_lock(&mutex);

        // 如果缓冲区已满，等待消费者消费
        while (count == BUFFER_SIZE) {
            pthread_cond_wait(&cond_empty, &mutex);
        }

        // 生产数据
        buffer[count] = i;
        count++;
        printf("Produced: %d\n", i);

        // 通知消费者
        pthread_cond_signal(&cond_full);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

// 消费者线程函数
void* consumer(void* arg) {
    for (int i = 0; i < 20; i++) {
        pthread_mutex_lock(&mutex);

        // 如果缓冲区为空，等待生产者生产
        while (count == 0) {
            pthread_cond_wait(&cond_full, &mutex);
        }

        // 消费数据
        int item = buffer[count - 1];
        count--;
        printf("Consumed: %d\n", item);

        // 通知生产者
        pthread_cond_signal(&cond_empty);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_t producer_thread, consumer_thread;

    // 创建生产者线程
    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_full);
    pthread_cond_destroy(&cond_empty);

    return 0;
}