Linux中的线程3

死锁

在Linux操作系统中，死锁（Deadlock）是指两个或多个进程（或线程）在执行过程中，因互相持有对方所需的资源而又都在等待对方释放资源，导致它们都无法继续执行下去的一种状态。这种僵局会浪费系统资源，甚至可能导致系统崩溃。

案例：

// 线程A和B，以及资源X和Y的初始状态

资源X: 空闲

资源Y: 空闲

线程A: 未持有资源

线程B: 未持有资源

// 线程A获取资源X

资源X: 被线程A持有

资源Y: 空闲

线程A: 持有资源X

线程B: 未持有资源

// 线程B获取资源Y

资源X: 被线程A持有

资源Y: 被线程B持有

线程A: 持有资源X

线程B: 持有资源Y

// 线程A请求资源Y，但资源Y被线程B持有，线程A阻塞

资源X: 被线程A持有

资源Y: 被线程B持有

线程A: 持有资源X，等待资源Y

线程B: 持有资源Y

// 线程B请求资源X，但资源X被线程A持有，线程B阻塞

资源X: 被线程A持有

资源Y: 被线程B持有

线程A: 持有资源X，等待资源Y

线程B: 持有资源Y，等待资源X

// 死锁发生，线程A和B都无法继续执行

造成的原因

死锁通常发生在多进程或多线程环境中，当满足以下四个条件时，就可能发生死锁：

1. 互斥条件：一个资源只能被一个进程（线程）访问，即资源独占。
2. 占有且等待：进程（线程）在占有一个资源时，可以请求其他资源。
3. 不可剥夺条件：一个资源只能由其持有者释放，不能强行剥夺。
4. 循环等待条件：多个进程（线程）之间形成一种循环等待资源的关系，每个进程（线程）等待下一个进程（线程）所持有的资源。

解决方式

为了避免和解决死锁，可以采取以下几种方法：

1. 资源预分配：在程序设计中尽量避免进程（线程）同时申请多个资源，通过资源预分配降低死锁的可能性。
2. 资源有序性：统一规定资源的获取顺序，尽量避免进程（线程）按不同的顺序请求资源。
3. 资源剥夺：当一个进程（线程）持有某些资源并请求其他资源时，如果无法满足请求，可以剥夺该进程（线程）之前所持有的资源。
4. 死锁检测与恢复：使用算法检测死锁的发生，并进行相应的恢复措施，例如终止某些进程（线程）或回滚操作。

读写锁

读写锁的基本概念

读写锁将线程对共享资源的访问请求分为读请求和写请求两种：

• 读请求：当多个线程发出读请求时，这些线程可以同时执行，共享数据的值可以同时被多个发出读请求的线程获取。
• 写请求：当多个线程发出写请求时，这些线程只能一个一个地执行（同步执行）。此外，当发出读请求的线程正在执行时，发出写请求的线程必须等待前者执行完后才能开始执行；反之亦然。
• 读写锁是一把锁

读写锁的核心特性

1. 读锁和写锁的互斥性：
   • 当一个线程持有写锁时，其他线程无法获取读锁或写锁（读写不可以同时进行）。
   • 当一个或多个线程持有读锁时，其他线程可以获取读锁，但无法获取写锁
   • （写的优先级高于读）。
2. 读锁的共享性：
   • 多个线程可以同时持有读锁，而不会相互阻塞。这是因为读取操作不会修改共享资源的数据，因此多个线程同时读取同一个资源不会产生数据竞争。
3. 写锁的独占性：
   • 只有一个线程可以持有写锁，其他线程必须等待该线程释放写锁后才能获取写锁。这是因为写入操作会修改共享资源的数据，如果多个线程同时写入同一个资源，就会导致数据不一致。
4. 引用计数机制：
   • 读写锁的实现通常采用引用计数的方式。当一个线程获取读锁时，读写锁会记录该线程的引用计数，只有当所有持有读锁的线程都释放读锁后，写线程才能获取写锁。这种方式可以确保在写线程获取写锁之前，所有读取操作都已经完成，从而避免数据竞争。

读写锁的操作

在Linux中，读写锁可以通过多种方式实现，包括但不限于使用POSIX线程（pthread）库中的函数。以下是一些常用的操作：

1. 初始化读写锁：
   • 使用PTHREAD_RWLOCK_INITIALIZER宏赋值给读写锁变量，或者调用pthread_rwlock_init()函数进行初始化。
2. 获取锁：
   • 读锁：通过pthread_rwlock_rdlock()或pthread_rwlock_tryrdlock()函数获取。前者在锁不可用时会阻塞线程，后者则不会阻塞线程，直接返回错误码。
   • 写锁：通过pthread_rwlock_wrlock()或pthread_rwlock_trywrlock()函数获取。同样，前者在锁不可用时会阻塞线程，后者则不会阻塞线程。
3. 释放锁：
   • 无论是读锁还是写锁，都可以通过pthread_rwlock_unlock()函数释放。
4. 销毁读写锁：
   • 当读写锁不再使用时，可以通过pthread_rwlock_destroy()函数将其销毁。

读写锁的应用场景

读写锁特别适用于那些对共享资源进行频繁读取而写入较少的场景。例如，在Web服务器中，缓存数据通常被频繁读取而很少写入，此时使用读写锁可以显著提升并发性能。

线程A加写锁成功，线程B请求读锁：

线程B阻塞

线程A持有读锁，线程B请求写锁 ：

线程B阻塞

线程A拥有读写，线程B请求读锁 ：

线程B加锁

线程A持有读锁，然后线程B请求写锁，然后线程C请求读锁：

线程B阻塞，线程C阻塞

线程B加锁，线程C阻塞

线程C加锁

线程A持有写锁，然后线程B请求读锁，然后线程C请求写锁 ：

线程B阻塞，线程C阻塞

线程C加锁， 线程B阻塞

线程B加锁

---------------------------------------------------------------------------------------------------------------------------------

互斥锁：读写串行

读写锁：

读：并行

写：串行

举例说明读写锁的具体应用

通过上面的代码可以预防读写的数据紊乱，使其能够正确读操作和写操作

条件变量

条件变量不是锁，可以阻塞线程（但不是什么时候都能阻塞线程）

条件变量通常与互斥锁（mutex）一起使用，以确保线程在访问共享资源或检查条件时的互斥性。

1. 条件变量的基本概念

    定义：条件变量是线程间同步的一种机制，它给多个线程提供了一个会合的场所。
    作用：通过允许线程阻塞和等待另一个线程发送信号的方法，条件变量弥补了互斥锁（Mutex）  的不足。
    使用场景：当线程需要等待某个条件成立时，可以使用条件变量来挂起线程，并在条件成立时被唤醒。

2. 条件变量的初始化

条件变量在使用前需要进行初始化。Linux中提供了两种初始化方式：

    静态初始化：使用宏PTHREAD_COND_INITIALIZER直接初始化静态分配的条件变量。

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

动态初始化：使用pthread_cond_init函数对动态分配的条件变量进行初始化。

pthread_cond_t cond;  

    pthread_cond_init(&cond, NULL); // NULL表示使用默认属性

3. 等待条件变量

线程可以通过调用pthread_cond_wait或pthread_cond_timedwait函数来等待（阻塞）条件变量。

    pthread_cond_wait：无限期等待条件变量变为真。

    pthread_cond_wait(&cond, &mutex);

在调用此函数之前，线程必须锁定与条件变量关联的互斥锁。函数内部会先解锁互斥锁，然后使线程阻塞在条件变量上。当条件变量被信号唤醒时，线程会重新锁定互斥锁并继续执行。

限时等待：pthread_cond_timedwait：等待条件变量变为真，但设置了超时时间。

struct timespec ts;  
clock_gettime(CLOCK_REALTIME, &ts);  
ts.tv_sec += timeout_seconds; // 设置超时时间

pthread_cond_timedwait(&cond, &mutex, &ts);

    此函数在达到超时时间或条件变量被信号唤醒时返回。

4. 通知条件变量

当条件成立时，可以通过调用pthread_cond_signal或pthread_cond_broadcast函数来通知等待条件变量的线程。

    pthread_cond_signal：唤醒等待条件变量的一个线程。

    pthread_cond_signal(&cond);

如果有多个线程在等待条件变量，则由调度策略决定哪个线程被唤醒。

pthread_cond_broadcast：唤醒等待条件变量的所有线程。

    pthread_cond_broadcast(&cond);

    这会导致所有等待条件变量的线程都被唤醒，但它们需要重新竞争互斥锁以访问共享资源。

5. 销毁条件变量

当条件变量不再需要时，应使用pthread_cond_destroy函数进行销毁。

pthread_cond_destroy(&cond);

6. 注意事项

    条件变量的使用必须配合互斥锁，以确保线程在访问共享资源或检查条件时的互斥性。
    pthread_cond_wait和pthread_cond_timedwait函数在返回时，都会重新锁定与条件变量关联的互斥锁。
    使用条件变量时，应避免唤醒丢失问题，即在条件变量被信号唤醒和线程重新锁定互斥锁之间，条件可能已经不再满足。

例：使用条件变量实现生产者，消费者模型

成功运行

修改后的源码如下

#include <stdio.h>  
#include <pthread.h>  
#include <unistd.h>  
#include <stdlib.h>  
#include <time.h> // 引入时间头文件，用于随机数生成  
  
// 定义链表节点结构体  
typedef struct node {  
    int data;           // 节点存储的数据  
    struct node* next;  // 指向下一个节点的指针  
} Node;  
  
// 全局变量  
Node* head = NULL;      // 链表头指针，初始为空  
pthread_mutex_t mutex;  // 互斥锁，用于保护共享资源（链表）  
pthread_cond_t cond;    // 条件变量，用于线程间同步  
  
// 生产者线程函数  
void* produce(void *arg) {  
    while (1) { // 无限循环，模拟持续生产  
        Node* pnew = (Node*)malloc(sizeof(Node)); // 分配新节点内存  
        if (!pnew) { // 内存分配失败检查  
            perror("malloc failed");  
            exit(EXIT_FAILURE); // 退出程序  
        }  
        pnew->data = rand() % 1000; // 生成0到999之间的随机数作为节点数据  
  
        pthread_mutex_lock(&mutex); // 加锁，保护链表操作  
        pnew->next = head; // 新节点指向当前头节点  
        head = pnew;       // 更新头节点为新节点  
        printf("Produce: %ld, %d\n", (long)pthread_self(), pnew->data); // 打印生产信息  
        pthread_cond_signal(&cond); // 发送信号，通知可能等待的消费者线程  
        pthread_mutex_unlock(&mutex); // 解锁  
  
        sleep(rand() % 3); // 生产者休眠随机时间，模拟生产耗时  
    }  
    return NULL; // 实际上这个return语句永远不会执行，因为存在无限循环  
}  
  
// 消费者线程函数  
void* consume(void *arg) {  
    while (1) { // 无限循环，模拟持续消费  
        pthread_mutex_lock(&mutex); // 加锁，保护链表操作  
        while (head == NULL) { // 如果链表为空，则等待  
            pthread_cond_wait(&cond, &mutex); // 等待条件变量，同时释放锁，并在条件满足时被唤醒时重新获取锁  
        }  
  
        Node* pdel = head; // 取出头节点作为待删除节点  
        head = head->next; // 更新头节点为下一个节点  
        printf("Consume: %ld, %d\n", (long)pthread_self(), pdel->data); // 打印消费信息  
        free(pdel); // 释放已消费节点的内存  
  
        pthread_mutex_unlock(&mutex); // 解锁  
  
        sleep(rand() % 2); // 消费者休眠随机时间，模拟消费耗时  
    }  
    return NULL; // 实际上这个return语句永远不会执行，因为存在无限循环  
}  
  
int main() {  
    pthread_t p1, p2; // 定义两个线程ID  
  
    srand(time(NULL)); // 初始化随机数生成器  
  
    pthread_mutex_init(&mutex, NULL); // 初始化互斥锁  
    pthread_cond_init(&cond, NULL); // 初始化条件变量  
  
    pthread_create(&p1, NULL, produce, NULL); // 创建生产者线程  
    pthread_create(&p2, NULL, consume, NULL); // 创建消费者线程  
  
    pthread_join(p1, NULL); // 等待生产者线程结束（注意：这里实际上会导致死锁，因为生产者有无限循环）  
    pthread_join(p2, NULL); // 等待消费者线程结束（同样，这也会导致死锁）  
  
    // 在实际应用中，你可能需要其他机制来优雅地终止线程，比如使用全局变量作为停止标志  
  
    pthread_mutex_destroy(&mutex); // 销毁互斥锁  
    pthread_cond_destroy(&cond); // 销毁条件变量  
  
    // 注意：由于生产者和消费者都有无限循环，这里的main函数实际上无法正常退出。  
    // 为了演示目的，这里保留了原样，但在实际应用中应该避免这种情况。  
  
    return 0; // 程序正常结束（但在这个例子中，由于线程的死循环，这行代码实际上不会被执行）  
}

信号量

一、概念

在Linux系统中，线程信号量（Semaphore）是一种用于控制多个线程对共享资源访问的同步机制。它本质上是一个非负整数计数器，用于协调多个线程对共享资源的访问。信号量不直接传输数据，而是作为一种许可或限制，确保在任何时刻，对共享资源的访问是安全的、有序的。

帮助理解：

假设有一个公共的水井，多个村民（线程）需要来打水（访问共享资源）。信号量就像是一个计数器，记录了当前水井旁可以容纳多少村民（信号量的值）。

• 当一个村民来打水时（线程访问共享资源），他首先查看信号量的值（调用sem_wait）。如果信号量的值大于0（表示水井旁还有空位），则他减去1（进入水井旁打水，信号量值减1），开始打水。如果信号量的值为0（表示水井旁已经满了），则他等待（线程被阻塞）。
• 当一个村民打完水离开时（线程完成共享资源的访问），他通过增加信号量的值（调用sem_post）来通知其他等待的村民（唤醒一个阻塞的线程）。

信号量主要用于实现两种功能：

1. 互斥（Mutual Exclusion）：确保同一时刻只有一个线程能够访问某个共享资源，防止数据竞争和不一致。
2. 同步（Synchronization）：协调多个线程的执行顺序，确保它们按照预期的顺序访问共享资源或执行特定操作。

二、相关函数

在Linux中，操作信号量的主要函数包括sem_init、sem_wait、sem_post、sem_getvalue和sem_destroy等。这些函数定义在<semaphore.h>头文件中，通常与pthread库一起使用。

1. sem_init
   • 功能：初始化一个信号量。
   • 原型：int sem_init(sem_t *sem, int pshared, unsigned int value);
   • 参数：
     • sem：指向信号量对象的指针。
     • pshared：指定信号量的作用域。0表示线程间共享，非0表示进程间共享。
     • value：信号量的初始值。
   • 返回值：成功返回0，失败返回-1。
2. sem_wait（P操作）
   • 功能：将信号量的值减1。如果信号量的值小于等于0，则调用线程将被阻塞，直到信号量的值大于0。
   • 原型：int sem_wait(sem_t *sem);
   • 参数：sem为指向信号量对象的指针。
   • 返回值：成功返回0，失败返回-1。
3. sem_post（V操作）
   • 功能：将信号量的值加1。如果有线程因为sem_wait调用而阻塞在该信号量上，则其中一个线程将被唤醒。
   • 原型：int sem_post(sem_t *sem);
   • 参数：sem为指向信号量对象的指针。
   • 返回值：成功返回0，失败返回-1。
4. sem_getvalue
   • 功能：获取信号量的当前值。
   • 原型：int sem_getvalue(sem_t *sem, int *sval);
   • 参数：
     • sem：指向信号量对象的指针。
     • sval：用于存储信号量当前值的指针。
   • 返回值：成功返回0，失败返回-1。
5. sem_destroy
   • 功能：销毁一个信号量，释放其资源。
   • 原型：int sem_destroy(sem_t *sem);
   • 参数：sem为指向信号量对象的指针。
   • 返回值：成功返回0，失败返回-1。

通过这种方式，信号量确保了任何时刻对水井的访问都是有序的，避免了冲突和混乱。

使用信号量知识点生成上个案例同样的功能

#include <stdio.h>  
#include <stdlib.h>  
#include <pthread.h>  
#include <semaphore.h>  
#include <unistd.h>  
#include <time.h>  
  
#define BUFFER_SIZE 10  
  
typedef struct node {  
    int data;  
    struct node* next;  
} Node;  
  
Node* head = NULL;  
Node* tail = NULL;  
  
// 信号量：用于控制队列的容量  
sem_t empty;  
// 信号量：用于同步生产者和消费者  
sem_t full;  
// 互斥锁：保护队列的修改  
pthread_mutex_t mutex;  
  
void* produce(void *arg) {  
    while (1) {  
        // 等待队列有空位  
        sem_wait(&empty);  
  
        // 加锁以保护队列  
        pthread_mutex_lock(&mutex);  
  
        // 创建新节点  
        Node* pnew = (Node*)malloc(sizeof(Node));  
        if (!pnew) {  
            perror("malloc failed");  
            pthread_mutex_unlock(&mutex);  
            sem_post(&empty); // 释放信号量，因为实际上没有增加队列中的元素  
            continue;  
        }  
  
        pnew->data = rand() % 1000;  
  
        // 将新节点添加到队列尾部  
        if (tail == NULL) {  
            head = tail = pnew;  
            pnew->next = NULL;  
        } else {  
            tail->next = pnew;  
            tail = pnew;  
            pnew->next = NULL;  
        }  
  
        // 解锁  
        pthread_mutex_unlock(&mutex);  
  
        // 通知消费者队列中有数据了  
        sem_post(&full);  
  
        printf("Produce: %d\n", pnew->data);  
  
        sleep(rand() % 3);  
    }  
    return NULL;  
}  
  
void* consume(void *arg) {  
    while (1) {  
        // 等待队列中有数据  
        sem_wait(&full);  
  
        // 加锁以保护队列  
        pthread_mutex_lock(&mutex);  
  
        // 从队列头部取出节点  
        Node* pdel = head;  
        if (head == NULL) {  
            // 理论上不应该发生，因为full信号量保证了队列不为空  
            pthread_mutex_unlock(&mutex);  
            sem_post(&empty); // 释放信号量，因为实际上没有消费任何数据  
            continue;  
        }  
  
        head = head->next;  
        if (head == NULL) {  
            tail = NULL; // 如果队列为空，则尾指针也为空  
        }  
  
        // 解锁  
        pthread_mutex_unlock(&mutex);  
  
        // 消费数据  
        printf("Consume: %d\n", pdel->data);  
  
        free(pdel);  
  
        // 通知生产者队列中有空位了  
        sem_post(&empty);  
  
        sleep(rand() % 2);  
    }  
    return NULL;  
}  
  
int main() {  
    pthread_t p1, p2;  
    sem_init(&empty, 0, BUFFER_SIZE); // 初始时队列为空，有BUFFER_SIZE个空位  
    sem_init(&full, 0, 0); // 初始时队列中没有数据  
    pthread_mutex_init(&mutex, NULL);  
  
    srand(time(NULL));  
  
    pthread_create(&p1, NULL, produce, NULL);  
    pthread_create(&p2, NULL, consume, NULL);  
  
    // 假设我们不想在这里等待线程结束，可以注释掉以下两行  
    // pthread_join(p1, NULL);  
    // pthread_join(p2, NULL);  
  
    // 注意：在实际应用中，你应该等待线程结束或者采取其他措施来避免程序过早退出  
  
    // 清理资源  
    // 注意：由于我们注释掉了pthread_join，这里的清理代码可能不会执行，或者执行时线程可能还在运行  
    // sem_destroy(&empty);  
    // sem_destroy(&full);  
    // pthread_mutex_destroy(&mutex);  
  
    return 0;  
}