Linux系统编程之线程与线程同步

一、线程概念及线程标识

        线程可以理解为一个正在运行的函数。posix线程是一套标准，而不是具体实现，所以不同系统会有不同的实现。该标准定义了pthread_t类型的线程标识，其中p表示posix，这一类型在不同系统下底层实现不同，所以不要打印线程ID.

1.pthread_equal()

        要比较两个pthread_t类型的变量是否相等可以使用pthread_equal()，相等返回非0，否则返回0.

2.pthread_self()

        要获取当前线程的线程ID可以使用pthread_self().

二、线程的创建

1.pthread_create()

        pthread_create()用于创建一个新的线程。

• thread：一个指向 pthread_t 类型的指针，用于存储新线程的标识符。
• attr：一个指向 pthread_attr_t 类型的指针，可以用于设置线程的属性。通常可以将其设置为 NULL，使用默认属性。
• start_routine：一个指向函数的指针，这个函数是新线程启动后要执行的函数。这个函数必须具有如下形式：void *function(void *arg)，其中 arg 是传递给 start_routine 的参数。
• arg：一个指向 void 类型的指针，用于传递给 start_routine 函数作为参数。

        成功返回0，失败返回error number，并且*thread的值是未定义的。

三、线程的终止与栈清理

        线程有四种终止方式：

                1）线程从启动例程中返回，返回值就是线程的退出码。

                2）被同一进程的其他线程取消(pthread_cancel)。

                3）任意其他线程调用exit()，或主线程从main函数中返回。这将导致所有线程的终止。

                4）调用pthread_exit()，并指定一个可以被同一进程的其他线程使用pthread_join()获取的退出码。

1.pthread_exit()

        该函数用于正常终止一个线程。

2.pthread_join()

        该函数用于回收一个线程资源，类似于进程编程的wait().

3.pthread_cancel()

        该函数用于取消指定线程。

         取消有两种状态，允许与不允许。允许取消又分为异步cancel和推迟cancel(推迟到cancel点)，默认是推迟cancel。

1）pthread_setcancelstate()

        该函数用于设置取消状态。

2）pthread_setcanceltype()

        该函数用于设置取消类型。

3）pthread_testcancel()

        该函数标识一个取消点。

4.pthread_cleanup_push(),pthread_cleanup_pop()

        这两个函数用于挂载线程结束时调用的处理函数。其中push用于将处理函数弹入栈中，pop用于弹出栈顶的处理函数并选择是否调用它。当线程结束时会将栈中所有处理函数弹出并调用。

         需要特别注意的是，这两个函数都是宏定义实现的，如果只有push展开后语句不完整，所以二者必须成对出现，即使你不需要pop，也要把pop语句放在pthread_exit()后面。

5.pthread_detach()

        该函数用于将一个线程分离出去，从而使别的线程不能join它，它的资源由系统自动释放。

        以下是线程创建与终止的简单示例： 

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

void *thread_function(void *arg) {
    int thread_arg = *(int *)arg;
    printf("Thread argument: %d\n", thread_arg);
    // 执行线程任务
    // ...
    pthread_exit(NULL);
}

int main() {
    pthread_t thread;
    int arg = 42;

    if (pthread_create(&thread, NULL, thread_function, &arg) != 0) {
        perror("pthread_create");
        return 1;
    }

    // 主线程继续执行其他任务

    // 等待线程结束
    if (pthread_join(thread, NULL) != 0) {
        perror("pthread_join");
        return 1;
    }

    return 0;
}

四、线程同步

1.互斥锁

        互斥锁主要是用在多线程编程时，多个线程同时访问同一个变量的情况下，保证在某一个时刻只能有一个线程访问。每个线程在访问共享变量的时候，首先要先获得锁，然后才能访问共享变量，当一个线程成功获得锁时，其他变量都会block在获取锁这一步，这样就达到了保护共享变量的目的。

1)pthread_mutex_destroy(),pthread_mutex_init()

        这两个函数用于销毁和初始化互斥锁。pthread_mutex_destroy()其实就是把传进来的pthread_mutex_t变量变为未初始化的状态，对这种状态的互斥锁的使用是未定义的，而pthread_mutex_init()可以把互斥锁重新变为初始化状态。该函数中的attr参数可以为NULL，此时该互斥锁的属性为默认属性。

        PTHREAD_MUTEX_INITIALIZER是一个宏，可以用于静态分配的初始化，并且属性为默认属性。

        销毁locked状态的锁是未定义的。

        二者成功均返回0，否则返回errno.

2)pthread_mutex_lock(),pthread_mutex_trylock(),pthread_mutex_unlock()

        lock()和trylock()函数用于将互斥锁变为locked状态，如果互斥锁已经是locked状态，lock()会阻塞等待其解锁，而trylock()不会阻塞。谁成功锁上了互斥锁谁就是该锁当前的持有者。

        unlock()函数用于解锁，如果互斥锁没被上锁或已被解锁，unlock()的行为由锁的属性决定。unlock()时如果有多个线程阻塞等待获取该锁，谁抢到由调度器策略决定。

        如果在等待锁的过程中有信号到来，线程会先处理信号然后继续等待。

        成功返回0，否则返回errno.

3)使用案例

         使用互斥锁来保护共享变量。

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

#define NUM_THREADS 2

// 全局变量，多个线程将共享它
int shared_variable = 0;

// 声明互斥锁
pthread_mutex_t mutex;

// 线程函数
void *thread_function(void *thread_id) {
    int tid = *((int *)thread_id);

    // 加锁
    pthread_mutex_lock(&mutex);

    // 临界区：修改共享变量
    printf("Thread %d is modifying the shared variable.\n", tid);
    shared_variable++;
    printf("Thread %d modified the shared variable to %d.\n", tid, shared_variable);

    // 解锁
    pthread_mutex_unlock(&mutex);

    pthread_exit(NULL);
}

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

    pthread_t threads[NUM_THREADS];
    int thread_ids[NUM_THREADS];

    // 创建多个线程
    for (int i = 0; i < NUM_THREADS; i++) {
        thread_ids[i] = i;
        int result = pthread_create(&threads[i], NULL, thread_function, &thread_ids[i]);
        if (result) {
            fprintf(stderr, "Error creating thread %d\n", i);
            return 1;
        }
    }

    // 等待所有线程完成
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

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

    // 输出最终的共享变量值
    printf("The final value of the shared variable is %d.\n", shared_variable);

    return 0;
}

2.条件变量

        条件变量是利用线程间共享的全局变量进行同步的一种机制。主要包括两个动作：一个线程等待”条件变量的条件成立”而挂起；另一个线程使”条件成立”（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。二者结合在一起可以实现类似PV操作的效果来同步线程。

1)pthread_cond_destroy(),pthread_cond_init()

        和互斥锁一样，这两个函数是用来销毁和创建条件变量的。当一个条件变量正在阻塞某个线程时销毁它会导致未定义行为。和互斥锁一样，条件变量也有静态初始化宏。

        成功返回0，否则返回errno.

2)pthread_cond_wait(),pthread_cond_timedwait()

         这两个函数都会原子地释放互斥锁并阻塞调用线程，也就是说下一个获取互斥锁的线程调用pthread_cond_broadcast()或pthread_cond_signal()之前当前线程已经被条件变量阻塞了。

        当这两个函数成功返回时，调用线程会持有互斥锁。也就是说，只有当互斥锁被释放后pthread_cond_*wait才会返回。

        当调用了pthread_cond_*wait()后条件变量会与互斥锁绑定，此时再用pthread_cond_*wait()将条件变量与其他锁绑定是未定义行为。所以多个线程要使用同一个条件变量时需要用一把互斥锁。

        pthread_cond_wait()和pthread_cond_timedwait()的区别在于后者有一个时间限制结构体参数，当阻塞到超时会返回错误。

        和互斥锁一样，当阻塞过程中有信号到来会先处理信号然后继续阻塞。但也有可能被虚假唤醒从而返回0.

        成功返回0，否则返回errno.

3)pthread_cond_broadcast(),pthread_cond_signal()

        这两个函数用于唤醒条件变量阻塞的线程，前者唤醒所有的，后者唤醒其中一个。唤醒以后被唤醒的线程不会立即解除阻塞，而是处于竞争状态，只有当获取到对应的互斥锁才会解除阻塞。

        当一个线程被唤醒，但没拿到锁，而另一个被唤醒并拿到锁的线程处理完后很快又解锁，此时没拿到锁的线程又会拿到锁，但条件可能已经不满足了，所以这是虚假唤醒。解决方法是用while循环判断条件而不是if.

        调用这两个函数时不需要持有与对应条件变量绑定的互斥锁。

        成功返回0，否则返回errno.

4)使用案例

        一个简单的生产-消费者模型，生产者线程在缓冲区未满时生产数据，消费者线程在缓冲区非空时消费数据。条件变量用于通知等待线程何时可以执行操作。

        注意，生产者在生产数据后唤醒消费者线程，而消费者在消费数据后唤醒生产者线程，以确保生产者和消费者之间的交替执行。互斥锁用于保护共享数据（buffer 和 count）的访问，以防止竞态条件。

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

#define BUFFER_SIZE 5

int buffer[BUFFER_SIZE];
int count = 0;
pthread_mutex_t mutex;
pthread_cond_t not_full, not_empty;

void *producer(void *arg) {
    int item;
    while (1) {
        item = rand() % 100;
        pthread_mutex_lock(&mutex);
        while (count == BUFFER_SIZE) {
            pthread_cond_wait(&not_full, &mutex);
        }
        buffer[count++] = item;
        printf("Producer produced: %d\n", item);
        pthread_cond_signal(&not_empty);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

void *consumer(void *arg) {
    int item;
    while (1) {
        pthread_mutex_lock(&mutex);
        while (count == 0) {
            pthread_cond_wait(&not_empty, &mutex);
        }
        item = buffer[--count];
        printf("Consumer consumed: %d\n", item);
        pthread_cond_signal(&not_full);
        pthread_mutex_unlock(&mutex);
        usleep(rand() % 1000000);  // Processing data
    }
    return NULL;
}

int main() {
    pthread_t producer_thread, consumer_thread;
    
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&not_full, NULL);
    pthread_cond_init(&not_empty, 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(&not_full);
    pthread_cond_destroy(&not_empty);
    
    return 0;
}

3.信号量

        和进程间通信类似，线程同步也可以使用信号量。在Linux中进程间通信一般使用的是systemV信号量，而在线程中一般使用posix的无名信号量，其使用接口更简单。

1)sem_init()

        该函数用于初始化一个无名信号量。

• sem：指向 sem_t 类型的信号量对象的指针。该对象将用于进行信号量操作。
• pshared：一个整数参数，指示信号量的共享性质。如果 pshared 为 0，表示信号量是线程局部的，只能在创建该信号量的线程和其子线程之间共享。如果 pshared 非零，表示信号量可以在进程之间共享。用于线程同步时设为 0.
• value：无符号整数，用于设置信号量的初始值。

需要注意的是如果pshared设为非0，在fork时子进程因为和父进程地址映射相同，子进程也可以访问该信号量。

        成功返回0，失败返回-1.

2)sem_wait(),sem_trywait(),sem_timedwait()

        这三个函数都用来进行信号量的P操作，不同的是sem_trywait()不会阻塞而是返回错误，sem_timedwait()有超时机制。

         成功返回0，失败时信号量的值不会变，并返回-1.

3)sem_post()

        该函数用于进行信号量的V操作。如果信号量值增加后大于0，该函数会唤醒某一个被P操作阻塞的线程。

        成功返回0，失败时信号量的值不会变，并返回-1.

4)sem_getval()

        该函数用于获取信号量当前值将其存在sval所指地址。当有线程/进程被P操作阻塞时posix规定信号量的值可以是0也可以是被阻塞线程/进程的数量的负数，Linux采用的是前者。

        成功返回0，失败返回-1. 

5)sem_destroy()

         该函数用于销毁一个无名信号量。销毁一个正在阻塞其他线程/进程的信号量是未定义行为。

使用一个被销毁的信号量也是一个未定义行为，除非它又被初始化了。

6)使用示例

        用信号量实现生产消费者模型。

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

#define BUFFER_SIZE 5

int buffer[BUFFER_SIZE];
sem_t empty, full;
pthread_mutex_t mutex;

void* producer(void* arg) {
    for (int i = 0; i < 10; i++) {
        int item = rand() % 100;  // 生产一个随机数
        sem_wait(&empty);
        pthread_mutex_lock(&mutex);
        buffer[i % BUFFER_SIZE] = item;
        printf("Produced: %d\n", item);
        pthread_mutex_unlock(&mutex);
        sem_post(&full);
    }
    return NULL;
}

void* consumer(void* arg) {
    for (int i = 0; i < 10; i++) {
        int item;
        sem_wait(&full);
        pthread_mutex_lock(&mutex);
        item = buffer[i % BUFFER_SIZE];
        printf("Consumed: %d\n", item);
        pthread_mutex_unlock(&mutex);
        sem_post(&empty);
    }
    return NULL;
}

int main() {
    pthread_t producer_thread, consumer_thread;

    sem_init(&empty, 0, BUFFER_SIZE);
    sem_init(&full, 0, 0);
    pthread_mutex_init(&mutex, 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);

    sem_destroy(&empty);
    sem_destroy(&full);
    pthread_mutex_destroy(&mutex);

    return 0;
}