线程同步--互斥锁，读写锁

线程同步

基本概念

线程的能力在于能够方便地通过全局变量或共享内存来交换信息，但这也带来了并发控制的复杂性，主要表现在如何安全地管理多个线程对共享资源的访问。这里涉及到几个关键的概念和技术：

临界区（Critical Section）

临界区是指那些访问共享资源（如全局变量、文件等）的代码段。为保证程序的正确性和避免数据竞争，这些代码段的执行必须是原子的，即在执行完整个代码段之前，不应被其他线程打断。管理临界区的方法主要包括使用互斥锁（mutexes）、信号量（semaphores）、读写锁（read-write locks）等同步机制。

线程同步

线程同步是指使线程以一种安全和确定的方式访问共享资源的各种机制。主要同步技术包括：

  1. 互斥锁（Mutex）

    • 用于保证同时只有一个线程可以进入临界区。线程在进入临界区之前必须获取锁，退出临界区时释放锁。如果锁已被其他线程占用，线程将阻塞直到锁被释放。

  2. 信号量（Semaphores）

    • 用于控制对共享资源的访问。信号量有一个计数器，表示可用资源的数量。线程在访问资源前需通过调用wait()操作来减少计数器，若计数器为零，则线程阻塞直到资源变为可用。完成资源访问后，线程调用signal()操作增加计数器。

  3. 条件变量（Condition Variables）

    • 允许线程在某些条件下阻塞，并在这些条件改变时被唤醒。通常与互斥锁配合使用，用于线程之间的协调和状态同步。

  4. 读写锁（Read-Write Locks）

    • 允许多个读操作同时进行，但写操作需要独占访问。这种锁是优化读取操作频繁而写入操作较少的场景。

实践中的应用

使用这些同步技术时，必须注意避免死锁、活锁和饥饿等问题。死锁发生时，多个线程相互等待对方持有的锁，从而无法继续执行。活锁是指线程虽然没有阻塞，但仍然无法向前推进，因为不断重试失败的操作。饥饿发生在某些线程无法获得必需的系统资源。

合理地使用线程同步技术可以显著提高程序在多核处理器上的性能，并发确保数据的一致性和完整性。在设计多线程程序时，开发者应当充分考虑这些因素，确保应用程序的稳定性和效率。如果需要具体的示例或进一步的解释，随时欢迎提问！

案例
/*
    使用多线程实现买票的案例。
    有3个窗口，一共是100张票。
*/

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

// 全局变量，所有的线程都共享这一份资源。
int tickets = 100;

void * sellticket(void * arg) {
    // 卖票
    while(tickets > 0) {
        usleep(6000);
        printf("%ld 正在卖第 %d 张门票\n", pthread_self(), tickets);
        tickets--;
    }
    return NULL;
}

int main() {

    // 创建3个子线程
    pthread_t tid1, tid2, tid3;
    pthread_create(&tid1, NULL, sellticket, NULL);
    pthread_create(&tid2, NULL, sellticket, NULL);
    pthread_create(&tid3, NULL, sellticket, NULL);

    // 回收子线程的资源,阻塞
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);

    // 设置线程分离。
    // pthread_detach(tid1);
    // pthread_detach(tid2);
    // pthread_detach(tid3);

    pthread_exit(NULL); // 退出主线程

    return 0;
}

daic@daic:~/Linux/linuxwebserver/part03Multithreading/lesson30$ gcc selltickets.c -lpthread
daic@daic:~/Linux/linuxwebserver/part03Multithreading/lesson30$ ./a.out 
139630428940032 正在卖第 100 张门票
139630420547328 正在卖第 100 张门票
139630437332736 正在卖第 100 张门票
139630420547328 正在卖第 97 张门票
139630428940032 正在卖第 97 张门票
139630437332736 正在卖第 95 张门票
139630420547328 正在卖第 94 张门票
139630428940032 正在卖第 93 张门票
139630437332736 正在卖第 92 张门票
139630420547328 正在卖第 91 张门票
139630437332736 正在卖第 90 张门票
139630428940032 正在卖第 91 张门票
139630420547328 正在卖第 88 张门票
139630437332736 正在卖第 87 张门票
139630428940032 正在卖第 86 张门票
139630420547328 正在卖第 85 张门票
139630437332736 正在卖第 84 张门票
139630428940032 正在卖第 83 张门票
139630420547328 正在卖第 82 张门票
139630428940032 正在卖第 81 张门票
139630437332736 正在卖第 80 张门票
139630420547328 正在卖第 79 张门票
139630428940032 正在卖第 78 张门票
139630437332736 正在卖第 77 张门票
139630420547328 正在卖第 76 张门票
139630428940032 正在卖第 75 张门票
139630437332736 正在卖第 74 张门票
139630420547328 正在卖第 73 张门票
139630428940032 正在卖第 72 张门票
139630437332736 正在卖第 71 张门票
139630420547328 正在卖第 70 张门票
139630428940032 正在卖第 69 张门票
139630437332736 正在卖第 68 张门票
139630420547328 正在卖第 67 张门票
139630428940032 正在卖第 66 张门票
139630437332736 正在卖第 65 张门票
139630420547328 正在卖第 64 张门票
139630437332736 正在卖第 63 张门票
139630428940032 正在卖第 62 张门票
139630420547328 正在卖第 61 张门票
139630437332736 正在卖第 60 张门票
139630428940032 正在卖第 59 张门票
139630420547328 正在卖第 58 张门票
139630428940032 正在卖第 57 张门票
139630437332736 正在卖第 56 张门票
139630420547328 正在卖第 55 张门票
139630428940032 正在卖第 54 张门票
139630437332736 正在卖第 53 张门票
139630420547328 正在卖第 52 张门票
139630428940032 正在卖第 51 张门票
139630437332736 正在卖第 50 张门票
139630420547328 正在卖第 49 张门票
139630428940032 正在卖第 48 张门票
139630437332736 正在卖第 47 张门票
139630420547328 正在卖第 46 张门票
139630428940032 正在卖第 45 张门票
139630437332736 正在卖第 44 张门票
139630420547328 正在卖第 43 张门票
139630428940032 正在卖第 42 张门票
139630437332736 正在卖第 41 张门票
139630420547328 正在卖第 40 张门票
139630428940032 正在卖第 39 张门票
139630437332736 正在卖第 38 张门票
139630420547328 正在卖第 37 张门票
139630428940032 正在卖第 36 张门票
139630437332736 正在卖第 35 张门票
139630420547328 正在卖第 34 张门票
139630428940032 正在卖第 33 张门票
139630437332736 正在卖第 32 张门票
139630420547328 正在卖第 31 张门票
139630428940032 正在卖第 30 张门票
139630437332736 正在卖第 29 张门票
139630420547328 正在卖第 28 张门票
139630428940032 正在卖第 27 张门票
139630437332736 正在卖第 26 张门票
139630428940032 正在卖第 25 张门票
139630420547328 正在卖第 24 张门票
139630437332736 正在卖第 23 张门票
139630420547328 正在卖第 22 张门票
139630428940032 正在卖第 21 张门票
139630437332736 正在卖第 20 张门票
139630420547328 正在卖第 19 张门票
139630428940032 正在卖第 19 张门票
139630437332736 正在卖第 17 张门票
139630420547328 正在卖第 16 张门票
139630428940032 正在卖第 16 张门票
139630437332736 正在卖第 14 张门票
139630420547328 正在卖第 13 张门票
139630428940032 正在卖第 12 张门票
139630437332736 正在卖第 11 张门票
139630420547328 正在卖第 10 张门票
139630428940032 正在卖第 9 张门票
139630437332736 正在卖第 8 张门票
139630420547328 正在卖第 7 张门票
139630428940032 正在卖第 6 张门票
139630437332736 正在卖第 5 张门票
139630420547328 正在卖第 4 张门票
139630428940032 正在卖第 3 张门票
139630437332736 正在卖第 2 张门票
139630420547328 正在卖第 1 张门票
139630428940032 正在卖第 0 张门票
139630437332736 正在卖第 -1 张门票

互斥锁

互斥量

在多线程编程中，互斥量是同步原语的一种，非常关键于防止所谓的“竞态条件”（race conditions），即多个线程同时访问和修改同一共享资源而引起的不可预测结果。

互斥量的工作原理

  • 状态: 互斥量有两种状态，已锁定（locked）和未锁定（unlocked）。
  • 操作: 主要操作包括锁定（lock）和解锁（unlock）。
  • 所有权: 只有锁定了互斥量的线程才能解锁它，这意味着锁的操作是关联线程所有权的。

使用互斥量的基本模式

当线程需要访问受互斥量保护的共享资源时，它会：

  1. 锁定互斥量: 确保如果其他线程已经锁定了互斥量，当前线程将等待（或阻塞）直到互斥量变为未锁定状态。
  2. 访问共享资源: 在安全的环境中进行操作，因为其他线程将无法同时访问这些资源。
  3. 解锁互斥量: 允许其他线程可以锁定互斥量并访问同一资源。

如果多个线程试图执行这一块代码（一个临界区），事实上只有一个线程能够持有该互斥

量（其他线程将遭到阻塞），即同时只有一个线程能够进入这段代码区域，如下图所示：

image-20240511061940228

互斥量相关操作函数

互斥量的类型 pthread_mutex_t
pthread_mutex_init

函数 pthread_mutex_init 用于初始化互斥量，是 POSIX 线程库中的一个重要函数。初始化是在互斥量使用之前必需的步骤，以确保互斥量在首次使用时处于已知的状态。

函数原型
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
参数说明
  • mutex：指向将要被初始化的 pthread_mutex_t 结构的指针。
  • attr：指向互斥量属性的指针。这个属性可以用来设置互斥量的类型（如普通、递归、错误检查等），如果传递 NULL，则使用默认属性。
返回值
  • 0：成功。
  • 错误码：在失败时返回一个错误码，而不是设置 errno。
错误码
  • EINVAL：传递了无效的属性。
  • ENOMEM：没有足够的内存来初始化互斥量。
使用示例

下面是一个简单的示例，展示如何初始化一个默认属性的互斥量，并使用它来同步两个线程的操作：

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

pthread_mutex_t lock;

void* function(void* arg) {
    pthread_mutex_lock(&lock);
    printf("Thread %ld is running\n", (long)arg);
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    pthread_t t1, t2;

    // 初始化互斥量
    pthread_mutex_init(&lock, NULL);

    // 创建两个线程
    pthread_create(&t1, NULL, function, (void*)1);
    pthread_create(&t2, NULL, function, (void*)2);

    // 等待线程结束
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    // 销毁互斥量
    pthread_mutex_destroy(&lock);

    return 0;
}

在这个示例中，我们创建了一个互斥量 lock，并在两个线程中使用它来同步对 printf 函数的调用，确保在同一时刻只有一个线程可以执行 printf。

注意事项

在使用完互斥量后，应调用 pthread_mutex_destroy 来释放任何可能由 pthread_mutex_init 分配的资源。

如果互斥量正在被使用（即处于锁定状态），则尝试初始化互斥量可能会导致未定义行为。因此，初始化应在创建任何使用它的线程之前完成。

正确地初始化互斥量对于确保程序的线程安全至关重要。

pthread_mutex_destroy

函数 pthread_mutex_destroy 用于销毁已经初始化的互斥量，释放它可能占用的资源。在多线程编程中，正确地初始化和销毁互斥量是保证资源正确管理的重要一环。

函数原型
#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);
参数说明
  • mutex：指向将要被销毁的 pthread_mutex_t 结构的指针。
返回值
  • 0：成功。
  • 错误码：如果函数调用失败，将返回一个非零的错误码。
错误码
  • EBUSY：尝试销毁一个正在被锁定或正在被其他线程等待的互斥量。在销毁互斥量之前，必须确保没有线程正在使用它。
  • EINVAL：传递给函数的互斥量指针无效。
注意事项
  • 在销毁互斥量之前，确保互斥量没有被锁定。如果互斥量被某个线程持有或其他线程正在等待锁定该互斥量，那么尝试销毁互斥量可能导致 EBUSY 错误。
  • 通常，pthread_mutex_destroy() 应该在所有使用互斥量的线程结束后调用，以确保所有线程均不会再访问该互斥量。
  • 正确的互斥量管理（初始化、使用、销毁）对于避免资源泄露和潜在的死锁至关重要。

确保遵循这些最佳实践可以帮助维持程序的稳定性和可靠性，尤其是在涉及多线程操作的环境中。

pthread_mutex_lock

pthread_mutex_lock 是 POSIX 线程库中的一个函数，用于在多线程程序中锁定互斥量（mutex）。当一个线程调用此函数时，它将尝试获取指定互斥量的所有权。如果互斥量已经被另一个线程锁定，调用线程将被阻塞，直到互斥量变为可用。这是确保对共享资源访问的互斥（排他性访问）的基本机制。

函数原型
#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
参数说明
  • mutex：指向互斥量的指针，该互斥量之前应已通过 pthread_mutex_init 初始化。
返回值
  • 0：成功锁定了互斥量。
  • 错误码：如果函数调用失败，将返回一个非零的错误码。
常见的错误码
  • EINVAL：传递给函数的互斥量指针无效。
  • EDEADLK：如果互斥量已经被当前线程锁定，并且互斥量是不允许递归锁定的，尝试重新锁定可能会返回此错误。
注意事项
  • 使用互斥量时，确保在访问任何受保护的共享资源前锁定互斥量，并在完成访问后释放（解锁）互斥量。
  • 避免在持有互斥量时执行长时间操作或可能导致线程阻塞的调用，以减少对其他线程的影响。
  • 要注意死锁的问题，特别是在多个互斥量涉及的情况下。确保以一致的顺序获取互斥量，避免循环等待条件的出现。

通过这种方式，互斥量帮助实现线程之间的同步，保证程序在并发环境中的正确性和效率。

pthread_mutex_trylock

函数 pthread_mutex_trylock 是 POSIX 线程库中的一个用于尝试锁定互斥量的函数，它与 pthread_mutex_lock 相似，但与后者不同的是，pthread_mutex_trylock 在无法立即获取互斥量时不会阻塞调用线程。这使得它成为避免潜在死锁和减少等待时间的有用工具。

函数原型
#include <pthread.h>
int pthread_mutex_trylock(pthread_mutex_t *mutex);
参数说明
  • mutex：指向互斥量的指针，该互斥量应已通过 pthread_mutex_init 初始化。
返回值
  • 0：成功锁定了互斥量。
  • EBUSY：互斥量已被另一个线程锁定，函数立即返回。
  • EINVAL：传递给函数的互斥量指针无效。
使用场景

pthread_mutex_trylock 非常适合于那些不希望线程在无法获取互斥量时长时间阻塞的场景，例如：

  • 在实时计算中，线程需要快速做出决策，不能因等待互斥量而延误。
  • 在尝试获取多个互斥量时，用于避免死锁，特别是当你无法保证所有线程都以相同顺序请求互斥量时。
示例代码

下面是一个简单的示例，展示如何使用 pthread_mutex_trylock 来尝试锁定互斥量，并根据返回值处理不同的情况：

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

pthread_mutex_t mutex;

void* trylock_thread(void* arg) {
    int trylock_result = pthread_mutex_trylock(&mutex);
    if (trylock_result == 0) {
        printf("Thread %ld: Got the lock\n", (long)arg);
        // 对共享资源进行操作
        pthread_mutex_unlock(&mutex);
    } else if (trylock_result == EBUSY) {
        printf("Thread %ld: Mutex is already locked by another thread\n", (long)arg);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;

    // 初始化互斥量
    pthread_mutex_init(&mutex, NULL);

    // 创建两个线程
    pthread_create(&t1, NULL, trylock_thread, (void*)1);
    pthread_create(&t2, NULL, trylock_thread, (void*)2);

    // 等待线程完成
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

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

    return 0;
}
注意事项
  • pthread_mutex_trylock 可以帮助你设计非阻塞的同步策略，但需要谨慎处理返回值，确保程序逻辑的正确性。
  • 使用此函数时，应考虑适当的错误处理和替代逻辑，特别是在获取锁失败时的操作。
  • 和所有互斥量操作一样，保证每次成功的 pthread_mutex_trylock 调用后都要有相应的 pthread_mutex_unlock 调用来释放互斥量。

通过合理使用 pthread_mutex_trylock，可以增加程序的响应速度和灵活性，同时避免因锁等待导致的性能瓶颈。

pthread_mutex_unlock

函数 pthread_mutex_unlock 是 POSIX 线程库中用于解锁互斥量的函数。这个函数通常在一个线程完成对受保护的共享资源的操作后调用，以释放互斥量，允许其他线程可以锁定此互斥量并访问相同的资源。解锁操作是保证多线程程序中资源共享和线程协作的重要环节。

函数原型
#include <pthread.h>
int pthread_mutex_unlock(pthread_mutex_t *mutex);
参数说明
  • mutex：指向需要被解锁的互斥量的指针。
返回值
  • 0：成功解锁互斥量。
  • 错误码：如果函数调用失败，将返回一个非零的错误码。
常见的错误码
  • EINVAL：传递给函数的互斥量指针无效。
  • EPERM：当前线程不是互斥量的所有者，尝试解锁它将返回这个错误。
注意事项
  • 使用 pthread_mutex_unlock 时必须确保当前线程确实是互斥量的所有者，否则会返回错误。
  • 通常情况下，每一个 pthread_mutex_lock 调用都应该对应一个 pthread_mutex_unlock 调用，以避免造成死锁。
  • 在设计使用互斥量的代码时，需要谨慎处理可能导致提前退出函数（如通过 return 语句或异常处理）的逻辑，确保即使在这些情况下互斥量也能被正确解锁。

通过合理使用互斥量的锁定与解锁操作，可以有效管理线程之间对共享资源的访问，保障数据的完整性和程序的稳定运行。

案例
/*
    互斥量的类型 pthread_mutex_t
    int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
        - 初始化互斥量
        - 参数 ：
            - mutex ： 需要初始化的互斥量变量
            - attr ： 互斥量相关的属性，NULL
        - restrict : C语言的修饰符，被修饰的指针，不能由另外的一个指针进行操作。
            pthread_mutex_t *restrict mutex = xxx;
            pthread_mutex_t * mutex1 = mutex;

    int pthread_mutex_destroy(pthread_mutex_t *mutex);
        - 释放互斥量的资源

    int pthread_mutex_lock(pthread_mutex_t *mutex);
        - 加锁，阻塞的，如果有一个线程加锁了，那么其他的线程只能阻塞等待

    int pthread_mutex_trylock(pthread_mutex_t *mutex);
        - 尝试加锁，如果加锁失败，不会阻塞，会直接返回。

    int pthread_mutex_unlock(pthread_mutex_t *mutex);
        - 解锁
*/
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

// 全局变量，所有的线程都共享这一份资源。
int tickets = 100;

// 创建一个互斥量，放在全局区
pthread_mutex_t mutex;

void * sellticket(void * arg) {

    // 卖票
    while(1) {

        // 加锁
        pthread_mutex_lock(&mutex);
        //临界区
        if(tickets > 0) {
            usleep(6000);
            printf("%ld 正在卖第 %d 张门票\n", pthread_self(), tickets);
            tickets--;
        }else {
            // 解锁
            pthread_mutex_unlock(&mutex);
            break;
        }

        // 解锁
        pthread_mutex_unlock(&mutex);
    }

    

    return NULL;
}

int main() {

    // 初始化互斥量
    pthread_mutex_init(&mutex, NULL);

    // 创建3个子线程
    pthread_t tid1, tid2, tid3;
    pthread_create(&tid1, NULL, sellticket, NULL);
    pthread_create(&tid2, NULL, sellticket, NULL);
    pthread_create(&tid3, NULL, sellticket, NULL);

    // 回收子线程的资源,阻塞
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);

    pthread_exit(NULL); // 退出主线程

    // 释放互斥量资源
    pthread_mutex_destroy(&mutex);

    return 0;
}

daic@daic:~/Linux/linuxwebserver/part03Multithreading/lesson30$ gcc mutex.c -lpthread
daic@daic:~/Linux/linuxwebserver/part03Multithreading/lesson30$ ./a.out 
140100915386112 正在卖第 100 张门票
140100915386112 正在卖第 99 张门票
140100915386112 正在卖第 98 张门票
140100915386112 正在卖第 97 张门票
140100915386112 正在卖第 96 张门票
140100915386112 正在卖第 95 张门票
140100915386112 正在卖第 94 张门票
140100915386112 正在卖第 93 张门票
140100915386112 正在卖第 92 张门票
140100915386112 正在卖第 91 张门票
140100915386112 正在卖第 90 张门票
140100915386112 正在卖第 89 张门票
140100915386112 正在卖第 88 张门票
140100915386112 正在卖第 87 张门票
140100915386112 正在卖第 86 张门票
140100915386112 正在卖第 85 张门票
140100915386112 正在卖第 84 张门票
140100915386112 正在卖第 83 张门票
140100915386112 正在卖第 82 张门票
140100915386112 正在卖第 81 张门票
140100915386112 正在卖第 80 张门票
140100915386112 正在卖第 79 张门票
140100915386112 正在卖第 78 张门票
140100915386112 正在卖第 77 张门票
140100915386112 正在卖第 76 张门票
140100915386112 正在卖第 75 张门票
140100915386112 正在卖第 74 张门票
140100915386112 正在卖第 73 张门票
140100915386112 正在卖第 72 张门票
140100915386112 正在卖第 71 张门票
140100915386112 正在卖第 70 张门票
140100915386112 正在卖第 69 张门票
140100915386112 正在卖第 68 张门票
140100915386112 正在卖第 67 张门票
140100915386112 正在卖第 66 张门票
140100915386112 正在卖第 65 张门票
140100915386112 正在卖第 64 张门票
140100915386112 正在卖第 63 张门票
140100915386112 正在卖第 62 张门票
140100915386112 正在卖第 61 张门票
140100915386112 正在卖第 60 张门票
140100915386112 正在卖第 59 张门票
140100915386112 正在卖第 58 张门票
140100915386112 正在卖第 57 张门票
140100915386112 正在卖第 56 张门票
140100915386112 正在卖第 55 张门票
140100915386112 正在卖第 54 张门票
140100915386112 正在卖第 53 张门票
140100915386112 正在卖第 52 张门票
140100915386112 正在卖第 51 张门票
140100915386112 正在卖第 50 张门票
140100915386112 正在卖第 49 张门票
140100915386112 正在卖第 48 张门票
140100915386112 正在卖第 47 张门票
140100915386112 正在卖第 46 张门票
140100915386112 正在卖第 45 张门票
140100915386112 正在卖第 44 张门票
140100915386112 正在卖第 43 张门票
140100915386112 正在卖第 42 张门票
140100915386112 正在卖第 41 张门票
140100915386112 正在卖第 40 张门票
140100915386112 正在卖第 39 张门票
140100915386112 正在卖第 38 张门票
140100915386112 正在卖第 37 张门票
140100915386112 正在卖第 36 张门票
140100915386112 正在卖第 35 张门票
140100915386112 正在卖第 34 张门票
140100915386112 正在卖第 33 张门票
140100915386112 正在卖第 32 张门票
140100915386112 正在卖第 31 张门票
140100915386112 正在卖第 30 张门票
140100915386112 正在卖第 29 张门票
140100915386112 正在卖第 28 张门票
140100915386112 正在卖第 27 张门票
140100915386112 正在卖第 26 张门票
140100915386112 正在卖第 25 张门票
140100915386112 正在卖第 24 张门票
140100898600704 正在卖第 23 张门票
140100898600704 正在卖第 22 张门票
140100898600704 正在卖第 21 张门票
140100898600704 正在卖第 20 张门票
140100898600704 正在卖第 19 张门票
140100898600704 正在卖第 18 张门票
140100898600704 正在卖第 17 张门票
140100898600704 正在卖第 16 张门票
140100898600704 正在卖第 15 张门票
140100898600704 正在卖第 14 张门票
140100898600704 正在卖第 13 张门票
140100898600704 正在卖第 12 张门票
140100898600704 正在卖第 11 张门票
140100898600704 正在卖第 10 张门票
140100898600704 正在卖第 9 张门票
140100898600704 正在卖第 8 张门票
140100898600704 正在卖第 7 张门票
140100898600704 正在卖第 6 张门票
140100898600704 正在卖第 5 张门票
140100898600704 正在卖第 4 张门票
140100898600704 正在卖第 3 张门票
140100898600704 正在卖第 2 张门票
140100898600704 正在卖第 1 张门票

死锁

死锁的常见场景

  1. 忘记释放锁
    • 描述：一个线程在获取锁之后，由于程序逻辑的问题，忘记释放锁，导致其他线程无限期地等待该锁。
    • 预防：确保每个pthread_mutex_lock调用都在函数结束前有对应的pthread_mutex_unlock调用，无论是通过正常路径还是错误处理路径。
  2. 重复加锁
    • 描述：一个线程试图对同一个非递归锁加锁多次，导致该线程自身陷入等待状态。
    • 预防：避免设计需要重复加锁同一互斥量的逻辑，或使用递归互斥量（允许同一线程多次加锁）。
  3. 多线程多锁
    • 描述：多个线程以不同的顺序获取多个互斥量，导致相互等待对方释放锁。
    • 预防：设计一个固定的锁获取顺序，所有线程必须按此顺序获取锁。例如，总是先锁定互斥量A，然后是互斥量B。

如何解决和预防死锁

  1. 锁的顺序获取
    • 一致的锁获取顺序可以防止环形等待条件的发生，这是死锁的四个必要条件之一。
  2. 检测并避免
    • 在设计时进行仔细的代码审核和测试，以检测可能的死锁情况。使用工具如Valgrind中的Helgrind，或使用静态分析工具来识别死锁风险。
  3. 超时机制
    • 使用带超时的锁获取尝试，如pthread_mutex_trylock或者使用具备超时功能的同步原语，如pthread_mutex_timedlock。如果锁在指定时间内未能获取，线程可以解锁已持有的其他锁，然后重试或回滚操作。
  4. 资源分配图
    • 在复杂的应用中，创建资源分配图来分析资源分配和锁定模式，从而识别潜在的死锁。
  5. 使用锁层次结构
    • 通过定义每个锁的层次，并且在代码中严格按层次获取锁，可以有效防止死锁。
案例1
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

// 全局变量，所有的线程都共享这一份资源。
int tickets = 1000;

// 创建一个互斥量
pthread_mutex_t mutex;

void * sellticket(void * arg) {

    // 卖票
    while(1) {

        // 加锁
        pthread_mutex_lock(&mutex);
        pthread_mutex_lock(&mutex);

        if(tickets > 0) {
            usleep(6000);
            printf("%ld 正在卖第 %d 张门票\n", pthread_self(), tickets);
            tickets--;
        }else {
            // 解锁
            pthread_mutex_unlock(&mutex);
            break;
        }

        // 解锁
        pthread_mutex_unlock(&mutex);
        pthread_mutex_unlock(&mutex);
    }

    return NULL;
}

int main() {

    // 初始化互斥量
    pthread_mutex_init(&mutex, NULL);

    // 创建3个子线程
    pthread_t tid1, tid2, tid3;
    pthread_create(&tid1, NULL, sellticket, NULL);
    pthread_create(&tid2, NULL, sellticket, NULL);
    pthread_create(&tid3, NULL, sellticket, NULL);

    // 回收子线程的资源,阻塞
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);

    pthread_exit(NULL); // 退出主线程

    // 释放互斥量资源
    pthread_mutex_destroy(&mutex);

    return 0;
}
案例2
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

// 创建2个互斥量
pthread_mutex_t mutex1, mutex2;

void * workA(void * arg) {

    pthread_mutex_lock(&mutex1);
    sleep(1); 
    pthread_mutex_lock(&mutex2);

    printf("workA....\n");

    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);
    return NULL;
}


void * workB(void * arg) {
    pthread_mutex_lock(&mutex2);
    sleep(1);
    pthread_mutex_lock(&mutex1);

    printf("workB....\n");

    pthread_mutex_unlock(&mutex1);
    pthread_mutex_unlock(&mutex2);

    return NULL;
}

int main() {

    // 初始化互斥量
    pthread_mutex_init(&mutex1, NULL);
    pthread_mutex_init(&mutex2, NULL);

    // 创建2个子线程
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, workA, NULL);
    pthread_create(&tid2, NULL, workB, NULL);

    // 回收子线程资源
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    // 释放互斥量资源
    pthread_mutex_destroy(&mutex1);
    pthread_mutex_destroy(&mutex2);

    return 0;
}

读写锁

为什么在某些应用中使用传统的互斥锁（mutex）可能不是最优选择，特别是在读操作远多于写操作的场合。这种场合下，读写锁（Read-Write Locks）或共享-独占锁（shared-exclusive locks）就显得非常有用。

读写锁的概念和特性

读写锁允许多个线程同时读共享资源，但保证只有一个线程可以写。它们解决了互斥锁在读多写少的应用场景中引起的性能瓶颈。主要特点包括：

  • 共享读：当没有线程持有读写锁用于写入时，多个线程可以同时持有读写锁用于读取。
  • 独占写：写操作需要独占访问，即当一个线程获取读写锁进行写操作时，其他线程无论是读还是写都必须等待。
  • 写优先：通常实现读写锁时会给写操作以较高的优先级，这防止写操作饥饿（长时间等待），尤其是在读操作非常频繁的情况下。

读写锁相关函数

读写锁的类型 pthread_rwlock_t

你提供的函数是 POSIX 线程（Pthreads）库中关于读写锁的操作函数。读写锁允许多个线程同时读取同一个共享资源，但在写入时要求独占访问。以下是各个函数的详细说明和用法：

pthread_rwlock_init

  • 功能：初始化一个读写锁。

  • 原型：

    int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);

  • 参数：

    • rwlock：指向将要初始化的读写锁的指针。
    • attr：指向读写锁属性的指针，可以设为 NULL 以使用默认属性。

  • 返回值：成功返回0；出错返回错误码。

pthread_rwlock_destroy

  • 功能：销毁一个读写锁。

  • 原型：

    int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

  • 参数：

    • rwlock：指向需要销毁的读写锁的指针。

  • 返回值：成功返回0；出错返回错误码。

pthread_rwlock_rdlock

  • 功能：以读模式锁定读写锁。

  • 原型：

    int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

  • 参数：

    • rwlock：指向要锁定的读写锁的指针。

  • 返回值：成功返回0；出错返回错误码。

pthread_rwlock_tryrdlock

  • 功能：尝试以读模式锁定读写锁。

  • 原型：

    int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

  • 参数：

    • rwlock：指向要尝试锁定的读写锁的指针。

  • 返回值：成功返回0；如果锁已经被其他线程以写模式锁定，返回EBUSY；其他错误返回相应的错误码。

pthread_rwlock_wrlock

  • 功能：以写模式锁定读写锁。

  • 原型：

    int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

  • 参数：

    • rwlock：指向要锁定的读写锁的指针。

  • 返回值：成功返回0；出错返回错误码。

pthread_rwlock_trywrlock

  • 功能：尝试以写模式锁定读写锁。

  • 原型：

    int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

  • 参数：

    • rwlock：指向要尝试锁定的读写锁的指针。

  • 返回值：成功返回0；如果锁已经被其他线程以读模式或写模式锁定，返回EBUSY；其他错误返回相应的错误码。

pthread_rwlock_unlock

  • 功能：解锁读写锁。

  • 原型：

    int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

  • 参数：

    • rwlock：指向要解锁的读写锁的指针。

  • 返回值：成功返回0；出错返回错误码。

使用示例

下面是一个使用读写锁的简单示例，展示了如何在多个线程中使用读写锁来同步对共享资源的访问：

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

pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
int shared_data = 0;

void* reader_function(void* arg) {
    pthread_rwlock_rdlock(&rwlock);
    printf("Reader: shared_data = %d\n", shared_data);
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

void* writer_function(void* arg) {
    pthread_rwlock_wrlock(&rwlock);
    shared_data++;
    printf("Writer: incremented shared_data to %d\n", shared_data);
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

int main

() {
    pthread_t reader_thread, writer_thread;
    
    pthread_rwlock_init(&rwlock, NULL);
    pthread_create(&reader_thread, NULL, reader_function, NULL);
    pthread_create(&writer_thread, NULL, writer_function, NULL);

    pthread_join(reader_thread, NULL);
    pthread_join(writer_thread, NULL);

    pthread_rwlock_destroy(&rwlock);
    return 0;
}

这个示例展示了如何初始化、使用和销毁读写锁，并说明了如何在读者和写者之间同步访问共享数据。通过使用读写锁，可以有效提升程序在多线程环境下处理读多写少情况的性能。

案例
/*
    读写锁的类型 pthread_rwlock_t
    int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
    int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
    int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
    int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
    int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
    int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
    int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

    案例：8个线程操作同一个全局变量。
    3个线程不定时写这个全局变量，5个线程不定时的读这个全局变量
*/

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

// 创建一个共享数据
int num = 1;
// pthread_mutex_t mutex;
pthread_rwlock_t rwlock;

void * writeNum(void * arg) {

    while(1) {
        pthread_rwlock_wrlock(&rwlock);
        num++;
        printf("++write, tid : %ld, num : %d\n", pthread_self(), num);
        pthread_rwlock_unlock(&rwlock);
        usleep(100);
    }

    return NULL;
}

void * readNum(void * arg) {

    while(1) {
        pthread_rwlock_rdlock(&rwlock);
        printf("===read, tid : %ld, num : %d\n", pthread_self(), num);
        pthread_rwlock_unlock(&rwlock);
        usleep(100);
    }

    return NULL;
}

int main() {

   pthread_rwlock_init(&rwlock, NULL);

    // 创建3个写线程，5个读线程(线程池)
    pthread_t wtids[3], rtids[5];
    for(int i = 0; i < 3; i++) {
        pthread_create(&wtids[i], NULL, writeNum, NULL);
    }

    for(int i = 0; i < 5; i++) {
        pthread_create(&rtids[i], NULL, readNum, NULL);
    }

    // 设置线程分离
    for(int i = 0; i < 3; i++) {
       pthread_detach(wtids[i]);
    }

    for(int i = 0; i < 5; i++) {
         pthread_detach(rtids[i]);
    }

    pthread_exit(NULL);

    pthread_rwlock_destroy(&rwlock);

    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/612539.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

走进C++：C到C++的过渡

走进C++：C到C++的过渡

目录 什么是C呢&#xff1f; C的发展史 多了一些吃前来很香的“语法糖”。 语法糖一&#xff1a;命名空间 命名空间有个强大的功能 如何使用 语法糖二&#xff1a;缺省参数 语法糖三&#xff1a;函数重载 语法糖四&#xff1a;引用 引用传参 引用返回 引用和…
阅读更多...
算法学习011-不同的二叉查找树/搜索树 c++动态规划算法实现 中小学算法思维学习 信奥算法解析

算法学习011-不同的二叉查找树/搜索树 c++动态规划算法实现 中小学算法思维学习 信奥算法解析

目录 C不同的二叉查找树 一、题目要求 1、编程实现 2、输入输出 二、算法分析 三、程序编写 四、运行结果 五、考点分析 六、推荐资料 C不同的二叉查找树 一、题目要求 1、编程实现 二叉查找树&#xff08;Binary Search Tree&#xff09;&#xff0c;&#xff08;…
阅读更多...
AI图书推荐：ChatGPT全面指南—用AI帮你更健康、更富有、更智慧

AI图书推荐：ChatGPT全面指南—用AI帮你更健康、更富有、更智慧

你是否在努力改善你的健康&#xff1f; 你是否长期遭受财务困难&#xff1f; 你想丰富你的思想、身体和灵魂吗&#xff1f; 如果是这样&#xff0c;那么这本书就是为你准备的。 《ChatGPT全面指南—用AI帮你更健康、更富有、更智慧》&#xff08;CHATGPT Chronicles AQuick…
阅读更多...
Mybatis-Plus常用的增删改查坑

Mybatis-Plus常用的增删改查坑

添加依赖 <!--实体类上加上Data注解就不用写get&#xff0c;set&#xff0c;toString&#xff0c;equals等方法了--><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional…
阅读更多...
Three.js基础练习——渲染一个立方体

Three.js基础练习——渲染一个立方体

1.学习内容参考了 three.js入门教程--零基础也能学会_threejs菜鸟教程-CSDN博客 本章内容包含渲染立方体&#xff0c;并配合ui工具食用~ 2.效果图 import * as THREE from three import * as dat from dat.gui import { OrbitControls } from three/addons/controls/OrbitC…
阅读更多...
ETL中如何执行Python脚本

ETL中如何执行Python脚本

Python的解读 Python 是一种高级、通用的编程语言&#xff0c;由荷兰程序员吉多范罗苏姆&#xff08;Guido van Rossum&#xff09;于1990年代初设计并发布。Python的设计哲学强调代码的可读性和简洁性&#xff0c;它的语法清晰且表达力强&#xff0c;使得开发者能够以更少的代…
阅读更多...
中国各地级市的海拔标准差数据集

中国各地级市的海拔标准差数据集

01、数据简介 海拔标准差是指对某个地点的海拔进行测量后&#xff0c;所得结果与平均海拔之间的差异。它反映了测量结果的离散程度&#xff0c;即海拔数据的可靠性。如果标准差较小&#xff0c;说明测量结果的可靠性较高&#xff1b;如果标准差较大&#xff0c;则说明测量结果…
阅读更多...
《解锁高效合同管理系统：优化业务流程，提升管理效率》

《解锁高效合同管理系统：优化业务流程，提升管理效率》

随着企业规模的扩大和业务复杂性的增加&#xff0c;合同管理变得愈发重要。合同是企业与客户、供应商、合作伙伴之间的法律约束和商业承诺&#xff0c;而有效的合同管理系统则成为企业提高运营效率、降低风险的关键工具。本文将探讨合同管理系统的重要性以及如何利用合同管理系…
阅读更多...
Electron 报错：WinState is not a constructor

Electron 报错：WinState is not a constructor

文章目录 问题分析 问题 在使用 electron-win-state 库时报错如下 代码如下&#xff1a; const WinState require(electron-win-state) const winState new WinState({ defaultWidth: 800,defaultHeight: 600,// other winState options, see below })const browserWindow…
阅读更多...
工作中使用Optional处理空指针异常

工作中使用Optional处理空指针异常

工作中使用Optional处理空指针异常 实体类以前对空指针的判断Optional处理空指针测试结果 实体类 package po;import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor;import java.io.Serializable;Data AllArgsConstructor NoArgsConstruct…
阅读更多...
【Vue2】关于response返回数据的错误小记

【Vue2】关于response返回数据的错误小记

关于Vue2中response返回数据的一个错误小记 如图&#xff0c;在这里返回的时候&#xff0c;后端是通过List< String >返回的&#xff0c;response接收到的实际上是一个Array数组&#xff0c;但是赋值给searchedTaskList的时候&#xff0c;需要在.then包括的范围里面赋值给…
阅读更多...
a-auto-complete 请求后端数据做模糊查询，解决下拉框选择选不上，不回显的问题

a-auto-complete 请求后端数据做模糊查询，解决下拉框选择选不上，不回显的问题

a-auto-complete 请求后端数据做模糊查询&#xff0c;解决下拉框选择选不上&#xff0c;不回显的问题 记录一个a-auto-complete卡bug卡了两天&#xff0c;找不到哪里的问题下拉框选择选不上&#xff0c;不回显&#xff0c;最后终于解决了。 我还对下拉框显示的内容做了小调整。…
阅读更多...
使用Vue调用ColaAI Plus大模型，实现聊天（简陋版）

使用Vue调用ColaAI Plus大模型，实现聊天（简陋版）

首先去百度文心注册申请自己的api 官网地址&#xff1a;LuckyCola 注册点开个人中心 查看这个文档自己申请一个ColaAI Plus定制增强大模型API | LuckyColahttps://luckycola.com.cn/public/docs/shares/api/colaAi.html来到vue的页面 写个样式 <template><Header …
阅读更多...
知识库文档系统源码部署/搭建/上线/运营/售后/更新

知识库文档系统源码部署/搭建/上线/运营/售后/更新

一款基于ThinkPHPFastAdmin开发的知识库文档系统&#xff0c;可用于企业工作流程的文档管理&#xff0c;结构化记录沉淀高价值信息&#xff0c;形成完整的知识体系&#xff0c;能够轻松提升知识的流转和传播效率&#xff0c;更好地成就组织和个人。为部门、团队或项目搭建知识库…
阅读更多...
Ubuntu/Linux 安装Docker + PyTorch

Ubuntu/Linux 安装Docker + PyTorch

文章目录 1. 提前准备2. 安装Docker2.1. 卸载冲突软件&#xff08;非必要&#xff09;2.2. 在Ubuntu系统上添加Docker的官方GPG密钥2.3. 将Docker的仓库添加到Ubuntu系统的APT源列表中2.4. 安装最新Docker2.5. 检查 3. 安装Nvidia Container Toolkit3.1. 在Ubuntu系统上添加官方…
阅读更多...
回炉重造java----双列集合(HashMap,TreeMap)

回炉重造java----双列集合(HashMap,TreeMap)

体系结构 ①基本操作: ②遍历方式: 第一种: 键找值&#xff0c;通过map.keySet()获取Map的键集合&#xff0c;通过键去匹配Map中的值 Set<String> strings map.keySet();for (String string : strings) {System.out.println(map.get(string));} 第二种: 键值对&…
阅读更多...
编程式导航

编程式导航

目录 一、问题引入 二、基本跳转 1.path路径跳转&#xff08;简易方便&#xff09; 2.name命名路由跳转&#xff08;适合path路径长的场景&#xff09; 三、路由传参 1.path路径跳转传参 &#xff08;1&#xff09;query传参 &#xff08;2&#xff09;动态路由传参 2.…
阅读更多...
【C++】CentOS环境搭建-安装log4cplus日志组件包及报错解决方案

【C++】CentOS环境搭建-安装log4cplus日志组件包及报错解决方案

log4cplus简介 log4cplus是C编写的开源的日志系统&#xff0c;前身是java编写的log4j系统&#xff0c;受Apache Software License保护&#xff0c;作者是Tad E. Smith。 log4cplus具有线程安全、灵活、以及多粒度控制的特点&#xff0c;通过将日志划分优先级使其可以面向程序…
阅读更多...
Linux 进程间通信 System V系列: 共享内存,信号量,简单介绍消息队列

Linux 进程间通信 System V系列: 共享内存,信号量,简单介绍消息队列

进程间通信 System V系列: 共享内存,初识信号量 一.共享内存1.引入2.原理3.系统调用接口1.shmget2.shmat和shmdt3.shmctl 4.边写代码边了解共享内存的特性1.ftok形成key,shmget创建与获取共享内存2.shm相关指令3.shmat和shmdt挂接和取消挂接4.shmctl获取共享内存信息,释放共享内…
阅读更多...
如何访问远程MySQL数据库服务器？

如何访问远程MySQL数据库服务器？

访问远程MySQL数据库服务器是一项常见的任务&#xff0c;它允许我们在不同的地点通过网络连接到MySQL服务器&#xff0c;并进行数据库管理和数据处理操作。我们将重点介绍一种名为【天联】的组网技术&#xff0c;该技术提供了一系列优势&#xff0c;使远程访问MySQL数据库服务器…
阅读更多...
最新文章

Copyright @ 2022~2023