Linux 多线程编程实例

针对“Linux 多线程编程实例”的完整攻略，我为你提供以下内容：

Linux 多线程编程的基础知识

进程与线程的概念

进程是资源分配的最小单位，线程是 CPU 调度的最小单位。

线程的优缺点

线程的优点在于线程的创建、销毁、上下文切换等开销相对较小，可以充分利用 CPU 资源，提高程序的并发性能，而缺点在于线程之间共享内存时需要进行同步和协调，比较容易出现死锁和竞争等问题。

线程的基本操作

线程的基本操作包括创建、销毁和同步等，其中使用 pthread 库可方便实现。

实例说明

示例一：计算 1 ~ 100 的和

如下为示例代码：

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

void* thread_func(void* arg) // 线程执行函数
{
    int sum = 0;
    for (int i = 1; i <= 100; ++i) {
        sum += i;
    }
    printf("thread sum = %d\n", sum);
    return NULL;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, NULL, thread_func, NULL); // 创建线程
    printf("main thread\n");
    pthread_join(tid, NULL); // 等待线程执行完成
    return 0;
}

以上示例中，创建了一个线程，线程执行函数为计算 1 ~ 100 的和，主线程则输出“main thread”，并等待子线程执行完成。最终输出结果为：

main thread
thread sum = 5050

示例二：生产者、消费者模型

如下为示例代码：

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

#define BUFFER_SIZE 10 // 缓冲区大小

int buffer[BUFFER_SIZE]; // 缓冲区
int in = 0, out = 0; // 缓冲区读写指针
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void* producer_func(void* arg) // 生产者线程执行函数
{
    for (int i = 1; i <= 20; ++i) {
        pthread_mutex_lock(&mutex);
        while ((in + 1) % BUFFER_SIZE == out) {
            printf("buffer is full\n");
            pthread_cond_wait(&cond, &mutex); // 等待，直到缓冲区非满
        }
        buffer[in] = rand() % 1000;
        printf("producer: %d, buffer[%d] = %d\n", i, in, buffer[in]);
        in = (in + 1) % BUFFER_SIZE;
        pthread_cond_signal(&cond); // 通知消费者线程，缓冲区非空
        pthread_mutex_unlock(&mutex);
        sleep(1); // 睡眠，模拟生产过程
    }
    return NULL;
}

void* consumer_func(void* arg) // 消费者线程执行函数
{
    for (int i = 1; i <= 20; ++i) {
        pthread_mutex_lock(&mutex);
        while (in == out) {
            printf("buffer is empty\n");
            pthread_cond_wait(&cond, &mutex); // 等待，直到缓冲区非空
        }
        int data = buffer[out];
        printf("consumer: %d, buffer[%d] = %d\n", i, out, data);
        out = (out + 1) % BUFFER_SIZE;
        pthread_cond_signal(&cond); // 通知生产者线程，缓冲区非满
        pthread_mutex_unlock(&mutex);
        sleep(1); // 睡眠，模拟消费过程
    }
    return NULL;
}

int main()
{
    pthread_t producer_tid, consumer_tid;
    pthread_create(&producer_tid, NULL, producer_func, NULL); // 创建生产者线程
    pthread_create(&consumer_tid, NULL, consumer_func, NULL); // 创建消费者线程
    pthread_join(producer_tid, NULL); // 等待生产者线程执行完成
    pthread_join(consumer_tid, NULL); // 等待消费者线程执行完成
    return 0;
}

以上示例为利用生产者、消费者模型实现线程间通信，其中生产者线程负责向缓冲区生产数据，消费者线程从缓冲区消费数据。在代码实现时，缓冲区使用数组实现，同时使用 mutex 和 cond 实现线程同步和互斥。最终输出结果为：

producer: 1, buffer[0] = 658
consumer: 1, buffer[0] = 658
producer: 2, buffer[1] = 753
consumer: 2, buffer[1] = 753
producer: 3, buffer[2] = 867
consumer: 3, buffer[2] = 867
producer: 4, buffer[3] = 64
consumer: 4, buffer[3] = 64
producer: 5, buffer[4] = 259
consumer: 5, buffer[4] = 259
producer: 6, buffer[5] = 285
consumer: 6, buffer[5] = 285
producer: 7, buffer[6] = 882
consumer: 7, buffer[6] = 882
producer: 8, buffer[7] = 361
consumer: 8, buffer[7] = 361
producer: 9, buffer[8] = 919
consumer: 9, buffer[8] = 919
producer: 10, buffer[9] = 883
consumer: 10, buffer[9] = 883
producer: 11, buffer[0] = 885
consumer: 11, buffer[0] = 885
producer: 12, buffer[1] = 560
consumer: 12, buffer[1] = 560
producer: 13, buffer[2] = 2
consumer: 13, buffer[2] = 2
producer: 14, buffer[3] = 497
consumer: 14, buffer[3] = 497
producer: 15, buffer[4] = 889
consumer: 15, buffer[4] = 889
producer: 16, buffer[5] = 998
consumer: 16, buffer[5] = 998
producer: 17, buffer[6] = 828
consumer: 17, buffer[6] = 828
producer: 18, buffer[7] = 936
consumer: 18, buffer[7] = 936
producer: 19, buffer[8] = 143
consumer: 19, buffer[8] = 143
producer: 20, buffer[9] = 825
consumer: 20, buffer[9] = 825

以上就是“Linux 多线程编程实例”的完整攻略，同时提供了两个不同的示例说明，希望可以帮到你。