Linux下线程间的通信

为什么需要线程通信？

线程是操作系统调度的最小单元，拥有自己的栈空间。
如果线程之间孤立运行，可能会导致资源浪费。
线程需要协调工作以完成共同的任务，这就需要线程间相互通信

在 Linux 系统中，线程间通信（Inter-Thread Communication, ITC）是多线程程序设计中的一个重要方面。由于线程共享相同的内存空间，它们可以直接通过读写共享变量来进行通信。

线程间通信的类型：

主线程向子线程传递参数

通过 pthread_create 函数的第四个参数 arg 传递。
arg 参数是一个 void* 类型的指针，可以指向任何类型的数据。

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

示例代码:

void* thread(void* args) 
{
    int num = *(int*)args;
    printf("num = %d\n", num);
    pthread_exit(NULL);
}

int main() {
    pthread_t thread_id;
    int num = 100;
    if (pthread_create(&thread_id, NULL, thread, &num) != 0) {
        fprintf(stderr, "pthread_creat error\n");
        exit(EXIT_FAILURE);
    }
    printf("thread id is %ld\n", thread_id);
    pthread_join(thread_id, NULL);
    return 0;
}

子线程向主线程传递参数

子线程通过 pthread_exit 函数的 retval 参数返回值。

void pthread_exit(void *retval);

主线程通过 pthread_join 函数的第二个参数 retval 获取返回值。

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

示例代码：

void* do_thread_function(void* args) {
    static float score = 92.3;
    pthread_exit(&score);
}

int main() {
    pthread_t thread_id;
    if (pthread_create(&thread_id, NULL, do_thread_function, NULL) != 0) {
        fprintf(stderr, "pthread_creat error\n");
        exit(EXIT_FAILURE);
    }
    printf("thread id is %ld\n", thread_id);
    void* res = NULL;
    pthread_join(thread_id, &res);
    printf("*res = %.2f\n", *(float*)res);
    return 0;
}

线程通信的同步机制：

在Linux环境下，线程间的通信主要依赖于操作系统提供的同步机制，以确保线程安全地访问共享资源。

互斥锁（Mutex）：

线程互斥锁（Mutex）是线程间通信中最基本的同步机制之一，用于保护临界区，确保同一时刻只有一个线程可以访问共享资源。

a.为什么要使用互斥锁？

使用线程互斥锁的主要原因是为了解决多线程程序中的数据竞争问题，确保数据的一致性和线程的同步执行。

当多个线程同时访问和修改同一数据时，如果没有适当的同步机制，可能会导致数据不一致。线程互斥锁可以确保在任何时刻只有一个线程能够访问和修改共享数据。
在多线程环境中，如果多个线程同时对数据进行读写操作，可能会导致数据的不一致性。互斥锁可以确保在修改数据时，其他线程不能访问该数据，从而保证数据的完整性
互斥锁可以用来控制线程的执行顺序，确保线程按照预期的顺序执行。例如，在一个线程完成某些初始化工作之前，其他线程需要等待

b.互斥锁的基础概念

线程互斥锁的工作原理：

锁定（Lock）：当一个线程想要访问共享资源时，它必须先获取互斥锁。如果互斥锁已经被其他线程持有，则该线程将被阻塞，直到互斥锁被释放。
解锁（Unlock）：当线程完成对共享资源的访问后，它会释放互斥锁，这样其他等待的线程就可以获取互斥锁并访问共享资源

线程互斥锁的特点：

互斥性：确保同一时刻只有一个线程可以持有锁。
原子性：获取和释放锁的操作是原子的，即它们是不可分割的。
死锁避免：通过正确的使用互斥锁，可以避免死锁的发生

c.线程互斥锁初始化

线程互斥锁的初始化是使用互斥锁之前的重要步骤，它为互斥锁设置了一个初始状态。在POSIX线程（pthread）库中，互斥锁的初始化可以通过两种方式进行：静态初始化和动态初始化

1.静态初始化

静态初始化是在编译时进行的，适用于在程序开始执行之前就已经确定了互斥锁的使用场景

#include <pthread.h>

pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

2.动态初始化

动态初始化是在程序执行过程中进行的，提供了更多的灵活性，比如可以设置互斥锁的属性

函数头文件：
#include <pthread.h>

函数原型：
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
           const pthread_mutexattr_t *restrict attr);

函数参数:
mutex：指向 pthread_mutex_t 类型变量的指针，这个变量用于存储互斥锁的状态。
attr（可选）：指向 pthread_mutexattr_t 类型变量的指针，这个变量包含了互斥锁的属性。如果不需要设置特殊属性，可以传递 NULL 来使用默认属性

函数返回值：
成功：返回0，表示函数调用成功，互斥锁初始化完成。
失败：返回错误码，表示函数调用失败

错误码：
EAGAIN：系统缺乏必要的资源(除了内存)来初始化另一个互斥锁
ENOMEM：内存不足，无法初始化互斥锁
EINVAL：提供的属性无效
EPERM：调用者没有执行操作的权限

3.销毁互斥锁

当互斥锁不再使用时，应该使用pthread_mutex_destroy函数销毁它，以释放任何资源

函数头文件：
#include <pthread.h>

函数原型：
int pthread_mutex_destroy(pthread_mutex_t *mutex);

函数参数：
mutex：指向 pthread_mutex_t 类型变量的指针，这个变量表示要销毁的互斥锁。

函数返回值：
成功：返回0，表示函数调用成功
失败：返回错误码，表示函数调用失败

错误码：
EBUSY：互斥锁仍然被某个线程持有，无法销毁。
EINVAL：mutex 参数无效或未初始化

d.线程互斥锁的操作

1.获取锁

函数头文件：
#include <pthread.h>

函数原型：
int pthread_mutex_lock(pthread_mutex_t *mutex);

函数参数：
mutex：指向 pthread_mutex_t 类型变量的指针，表示要锁定的互斥锁

函数返回值:
成功：返回0,表示函数调用成功
失败：返回错误码，指示错误

错误码：
EBUSY：互斥锁已被其他线程锁定，且无法立即获得。
EAGAIN：表示系统资源不足，无法立即锁定互斥锁。这通常发生在系统资源限制，如达到最大互斥锁数量时。
EINVAL：mutex 参数无效，表示互斥锁对象无效或未正确初始化。
EPERM：当设置了一个健壮（robust）互斥锁，并且互斥锁的原拥有者终止了，而没有解锁。新线程试图锁定这个互斥锁时，会得到此错误

2.释放锁

函数头文件：
#include <pthread.h>

函数原型：
int pthread_mutex_unlock(pthread_mutex_t *mutex);

函数参数：
mutex：指向 pthread_mutex_t 类型变量的指针，表示要锁定的互斥锁

函数返回值:
成功：返回0,表示函数调用成功
失败：返回错误码，指示错误

错误码：
EPERM：调用线程不拥有互斥锁。在POSIX标准中，试图解锁一个未锁定的互斥锁或由其他线程持有的互斥锁会导致这个错误。
EINVAL：mutex 参数无效，可能是因为它未初始化，或者是一个损坏的互斥锁对象

互斥锁示例代码（使用动态初始化）：

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

pthread_mutex_t mutex;

void* thread_function(void* arg) {
    // 获取锁
    int result = pthread_mutex_lock(&mutex);
    if (result != 0) {
        fprintf(stderr, "互斥锁锁定失败: %s\n", strerror(result));
        exit(EXIT_FAILURE);
    }

    // 访问共享资源
    printf("访问共享资源\n");

    // 释放锁
    result = pthread_mutex_unlock(&mutex);
    if (result != 0) {
        fprintf(stderr, "互斥锁解锁失败: %s\n", strerror(result));
        exit(EXIT_FAILURE);
    }

    return NULL;
}

int main() {
    int result = pthread_mutex_init(&mutex, NULL);
    if (result != 0) {
        fprintf(stderr, "互斥锁初始化失败: %s\n", strerror(result));
        exit(EXIT_FAILURE);
    }

    pthread_t thread;
    result = pthread_create(&thread, NULL, thread_function, NULL);
    if (result != 0) {
        fprintf(stderr, "线程创建失败: %s\n", strerror(result));
        exit(EXIT_FAILURE);
    }

    pthread_join(thread, NULL);
    pthread_mutex_destroy(&mutex);

    return 0;
}