• Linux系统编程-线程同步详解

    线程同步是指多个线程协调工作，以便在共享资源的访问和操作过程中保持数据一致性和正确性。在多线程环境中，线程是并发执行的，因此如果多个线程同时访问和修改共享资源，可能会导致数据不一致、竞态条件（race condition）等问题。线程同步通过协调线程的执行顺序和共享资源的访问来避免这些问题。

    在多线程编程中，需要线程同步的主要原因包括：

    • 共享资源的安全访问：多个线程可能同时访问和修改共享的数据或资源，如果没有同步机制，可能会导致数据不一致或损坏。

    • 避免竞态条件：竞态条件是指多个线程以不受控制的顺序访问共享资源，从而导致程序执行结果不确定的情况。通过同步机制可以避免竞态条件的发生。

    • 保证程序正确性：线程同步确保多线程程序的行为是可预测和正确的，避免因并发访问而引入的错误。

    1.互斥量（Mutex）

    互斥量（互斥锁）是一种最基本的同步机制，用于保护临界区（Critical Section），确保在同一时间只有一个线程可以访问共享资源。

    它提供了两个主要操作：

    • 加锁（Locking）：线程通过加锁操作获取互斥量，如果互斥量已经被其他线程锁定，则当前线程会阻塞，直到获取到锁。
    • 解锁（Unlocking）：线程使用解锁操作释放互斥量，允许其他线程获取锁。

    通过这种机制，互斥量确保了临界区中的代码在同一时间只能被一个线程执行，从而避免了数据竞争和不一致的问题。

    1.1初始化和销毁互斥量：

    1.1.1pthread_mutex_init()

    初始化互斥量，并可选地设置其属性。

    1. int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
    2. 参数：
    3. pthread_mutex_t *mutex：指向互斥量变量的指针，用于初始化该互斥量。
    4. const pthread_mutexattr_t *attr：可选参数，指向 pthread_mutexattr_t 类型的指针，用于设置互斥量的属性。如果为 NULL，使用默认属性。
    5. 返回值：
    6. 成功：返回 0。
    7. 失败：返回错误号（例如 EINVAL 表示参数无效）。
    • 初始化互斥量后需要调用 pthread_mutex_destroy 函数来释放其占用的资源。
    • 通常在使用互斥量前调用，确保互斥量的准备和设置。

    1.1.2pthread_mutex_destroy()

    销毁互斥量，释放其占用的资源。

    1. int pthread_mutex_destroy(pthread_mutex_t *mutex);
    2. 参数：
    3. pthread_mutex_t *mutex：指向要销毁的互斥量变量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回错误号。
    • 在互斥量不再需要时调用，以释放其占用的资源。
    • 仅当确保没有线程在使用该互斥量时才能安全地调用该函数。

    1.2加锁和解锁操作：

    1.2.1pthread_mutex_lock()

    加锁操作，阻塞当前线程直到获取锁。

    1. int pthread_mutex_lock(pthread_mutex_t *mutex);
    2. 参数：
    3. pthread_mutex_t *mutex：指向要加锁的互斥量变量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回错误号。
    • 当互斥量已经被其他线程锁定时，当前线程会阻塞直到获取锁。
    • 必须成对使用 pthread_mutex_lock 和 pthread_mutex_unlock 来保护临界区。

    1.2.2pthread_mutex_trylock()

    尝试加锁操作，非阻塞式，立即返回结果。

    1. int pthread_mutex_trylock(pthread_mutex_t *mutex);
    2. 参数：
    3. pthread_mutex_t *mutex：指向要加锁的互斥量变量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回 EBUSY（互斥量已被锁定）或其他错误号。
    • 如果互斥量已被锁定，则立即返回错误。
    • 适用于需要非阻塞尝试加锁的情况，可以用于避免线程阻塞。

    1.2.3pthread_mutex_unlock()

    解锁操作，释放互斥量。

    1. int pthread_mutex_unlock(pthread_mutex_t *mutex);
    2. 参数：
    3. pthread_mutex_t *mutex：指向要解锁的互斥量变量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回错误号。
    • 解锁后允许其他线程获取互斥量。
    • 必须在每次成功调用 pthread_mutex_lock 后调用 pthread_mutex_unlock 来释放锁。

    示例代码：

    创建两个线程来共享一个全局变量 int number，然后每个线程分别对其进行5000次递增操作，同时使用互斥量来保证线程同步。（如果没有锁大家可以看看会发生什么情况）

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. #define NUM_THREADS 2
    6. #define NUM_INCREMENTS 5000
    7.  
    8. int number = 0;
    9. pthread_mutex_t mutex;  // 互斥量变量
    10.  
    11. void* thread_function(void* arg) {
    12.     int thread_id = *(int*)arg;
    13.  
    14.     for (int i = 0; i < NUM_INCREMENTS; ++i) {
    15.         // 加锁
    16.         pthread_mutex_lock(&mutex);
    17.  
    18.         // 临界区：对共享变量 number 执行操作
    19.         number++;
    20.  
    21.         // 解锁
    22.         pthread_mutex_unlock(&mutex);
    23.     }
    24.  
    25.     pthread_exit(NULL);
    26. }
    27.  
    28. int main() {
    29.     pthread_t threads[NUM_THREADS];
    30.     int thread_ids[NUM_THREADS];
    31.  
    32.     // 初始化互斥量
    33.     if (pthread_mutex_init(&mutex, NULL) != 0) {
    34.         fprintf(stderr, "Mutex initialization failed\n");
    35.         return 1;
    36.     }
    37.  
    38.     // 创建两个线程
    39.     for (int i = 0; i < NUM_THREADS; ++i) {
    40.         thread_ids[i] = i;
    41.         if (pthread_create(&threads[i], NULL, thread_function, &thread_ids[i]) != 0) {
    42.             fprintf(stderr, "Thread creation failed\n");
    43.             return 1;
    44.         }
    45.     }
    46.  
    47.     // 等待所有线程结束
    48.     for (int i = 0; i < NUM_THREADS; ++i) {
    49.         pthread_join(threads[i], NULL);
    50.     }
    51.  
    52.     // 销毁互斥量
    53.     pthread_mutex_destroy(&mutex);
    54.  
    55.     // 输出最终的 number 值
    56.     printf("Final value of number: %d\n", number);
    57.  
    58.     return 0;
    59. }

    1.3死锁（Deadlock）

    死锁并不是linux提供给用户的一种使用方法，而是由于用户使用互斥锁不当引起的一种现象。死锁发生在多个并发执行的线程（或进程）之间，主要由于彼此竞争资源而造成。典型的死锁情况涉及两个或多个线程或进程，每个都在等待对方释放其持有的资源，导致所有线程都被阻塞，无法继续执行下去。

    常见的死锁有两种：

    第一种：自己锁自己，如下图代码片段

    第二种 线程A拥有A锁，请求获得B锁；线程B拥有B锁，请求获得A锁，这样造成线程A和线程B都不释放自己的锁，而且还想得到对方的锁，从而产生死锁，如下图所示：

    • 如何解决死锁：
    • 让线程按照一定的顺序去访问共享资源
    • 在访问其他锁的时候，需要先将自己的锁解开
    • 调用pthread_mutex_trylock，如果加锁不成功会立刻返回

    2. 条件变量（Condition Variable）

    条件变量（Condition Variable） 是一种线程间同步的机制，通常与互斥锁结合使用，用于在某个条件满足时通知其他线程。条件变量允许线程在等待某个特定条件的同时阻塞，直到另一个线程显式地通知条件已经满足或者超时。条件本身不是锁！但它也可以造成线程阻塞。通常与互斥锁配合使用。给多线程提供一个会合的场所。

    • 使用互斥量保护共享数据。
    • 使用条件变量可以使线程阻塞, 等待某个条件的发生, 当条件满足的时候解除阻塞。

    主要作用包括：

    • 等待条件：使线程能够在满足特定条件之前进入休眠状态，节省系统资源。
    • 条件满足时通知：一旦其他线程改变了条件，可以通过条件变量通知正在等待的线程继续执行。

    2.1相关操作函数

    2.1.1pthread_cond_init()

    初始化条件变量 cond。

    1. int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
    2. 参数：
    3. pthread_cond_t *restrict cond：指向要初始化的条件变量的指针。
    4. const pthread_condattr_t *restrict attr：可选参数，指向 pthread_condattr_t 类型的指针，用于设置条件变量的属性。通常可以设置为 NULL，表示使用默认属性。
    5. 返回值：
    6. 成功：返回 0。
    7. 失败：返回错误号（例如 EINVAL 表示参数无效）。
    • 初始化条件变量后，应当使用 pthread_cond_destroy 函数来释放其占用的资源。
    • 通常在创建条件变量后立即调用该函数进行初始化。

    2.1.2pthread_cond_destroy()

    销毁条件变量 cond，释放其占用的资源。

    1. int pthread_cond_destroy(pthread_cond_t *cond);
    2. 参数：
    3. pthread_cond_t *cond：指向要销毁的条件变量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回错误号。
    • 在条件变量不再需要时调用，以释放其占用的资源。
    • 确保没有线程在使用该条件变量时才能安全地调用该函数。

    2.1.3pthread_cond_wait()

    阻塞当前线程，等待条件变量 cond 被其他线程信号唤醒。

    1. int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
    2. 参数：
    3. pthread_cond_t *restrict cond：指向要等待的条件变量的指针。
    4. pthread_mutex_t *restrict mutex：与条件变量相关联的互斥锁，用于避免竞态条件。
    5. 返回值：
    6. 成功：返回 0。
    7. 失败：返回错误号。
    • 调用该函数前必须先获取 mutex 锁，函数内部会自动释放 mutex 锁，并在等待期间阻塞当前线程。
    • 当被唤醒时，函数内部会再次获取 mutex 锁，并从函数返回。

    2.1.4pthread_cond_timedwait()

    在指定的超时时间内阻塞当前线程，等待条件变量 cond 被其他线程信号唤醒。

    1. int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
    2. 参数：
    3. pthread_cond_t *restrict cond：指向要等待的条件变量的指针。
    4. pthread_mutex_t *restrict mutex：与条件变量相关联的互斥锁。
    5. const struct timespec *restrict abstime：指定的超时时间，为绝对时间。
    6. 返回值：
    7. 成功：返回 0。
    8. 失败：返回错误号。
    • 与 pthread_cond_wait 类似，但可以设置超时时间，在超时之后会自动返回并解除阻塞。
    • 如果超时时间设置为 NULL，则函数将无限期地等待，直到条件变量被信号唤醒。

    2.1.5pthread_cond_signal()

    唤醒等待在条件变量 cond 上的一个线程。

    1. int pthread_cond_signal(pthread_cond_t *cond);
    2. 参数：
    3. pthread_cond_t *cond：指向要唤醒的条件变量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回错误号。
    • 唤醒等待在条件变量上的一个线程，如果有多个线程等待，则可能唤醒任意一个。
    • 唤醒后，被唤醒的线程将尝试重新获取与条件变量关联的互斥锁。

    示例代码：

    使用条件变量实现生产者与消费者模型

    3. 读写锁（Read-Write Lock）

    读写锁允许多个线程同时对共享资源进行读取操作，但是写操作时需要排他性，即同一时刻只能有一个线程进行写操作。这种区分读和写的方式能够有效地提高系统的并发性能，特别适用于数据结构中读操作远远多于写操作的情况。当读写锁以读模式锁住时，它是以共享模式锁住的；当它以写模式锁住时，它是以独占模式锁住的。写独占、读共享。

    读写锁特性:

    • 读写锁是“写模式加锁”时，解锁前，所有对该锁加锁的线程都会被阻塞。
    • 读写锁是“读模式加锁”时，如果线程以读模式对其加锁会成功；如果线程以写模式加锁会阻塞。
    • 读写锁是“读模式加锁”时， 既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞，写锁优先级高

    3.1初始化和销毁读写锁

    3.1.1pthread_rwlock_init()

    初始化读写锁 rwlock，可以选择性地设置其属性。

    1. int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
    2. 参数：
    3. pthread_rwlock_t *restrict rwlock：指向要初始化的读写锁变量的指针。
    4. const pthread_rwlockattr_t *restrict attr：可选参数，指向 pthread_rwlockattr_t 类型的指针，用于设置读写锁的属性。通常可以设置为 NULL，表示使用默认属性。
    5. 返回值：
    6. 成功：返回 0。
    7. 失败：返回错误号（例如 EINVAL 表示参数无效）。
    • 初始化读写锁后，应当使用 pthread_rwlock_destroy 函数来释放其占用的资源。
    • 通常在创建读写锁后立即调用该函数进行初始化。

    3.1.2pthread_rwlock_destroy()

    销毁读写锁 rwlock，释放其占用的资源。

    1. int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
    2. 参数：
    3. pthread_rwlock_t *rwlock：指向要销毁的读写锁变量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回错误号。
    • 在读写锁不再需要时调用，以释放其占用的资源。
    • 确保没有线程在使用该读写锁时才能安全地调用该函数。

    3.2读写锁加锁和解锁操作：

    3.2.1pthread_rwlock_rdlock()

    加读锁，允许多个线程同时对共享资源进行读取操作。

    1. int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
    2. 参数：
    3. pthread_rwlock_t *rwlock：指向要加读锁的读写锁变量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回错误号。
    • 如果有其他线程持有写锁或者有线程在请求写锁，则当前线程将被阻塞，直到获取读锁为止。
    • 多个线程可以同时获取读锁，不会相互阻塞。

    3.2.2pthread_rwlock_wrlock()

    加写锁，确保只有一个线程可以对共享资源进行写操作，期间禁止其他线程的读或写操作。

    1. int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
    2. 参数：
    3. pthread_rwlock_t *rwlock：指向要加写锁的读写锁变量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回错误号。
    • 如果有其他线程持有读锁或写锁，则当前线程将被阻塞，直到获取写锁为止。
    • 只能有一个线程可以同时持有写锁，其他线程无法同时获取读锁或写锁。

    3.2.3pthread_rwlock_tryrdlock()

    尝试加读锁，非阻塞方式。如果不能立即获得锁，则立即返回。

    1. int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
    2. 参数：
    3. pthread_rwlock_t *rwlock：指向要加读锁的读写锁变量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回 EBUSY（读写锁已被写锁占用）或其他错误号。
    • 如果不能立即获取读锁，则该函数立即返回失败。
    • 适用于需要检测是否可以立即读取共享资源的场景。

    3.2.4pthread_rwlock_trywrlock()

    尝试加写锁，非阻塞方式。如果不能立即获得锁，则立即返回。

    1. int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
    2. 参数：
    3. pthread_rwlock_t *rwlock：指向要加写锁的读写锁变量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回 EBUSY（读写锁已被其他线程占用）或其他错误号。
    • 如果不能立即获取写锁，则该函数立即返回失败。
    • 适用于需要检测是否可以立即写入共享资源的场景。

    3.2.5pthread_rwlock_unlock()

    解锁操作，释放之前加的读锁或写锁。

    1. int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
    2. 参数：
    3. pthread_rwlock_t *rwlock：指向要解锁的读写锁变量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回错误号。
    • 解锁后允许其他线程获取读锁或写锁。
    • 必须在每次成功调用 pthread_rwlock_rdlock 或 pthread_rwlock_wrlock 后调用该函数来释放锁。

    示例代码：

    其中包括3个写线程和5个读线程对同一个全局资源进行操作。每个线程都会不定时地访问和修改这个全局资源，并通过读写锁确保线程之间的同步。

    1. #include 
    2. #include 
    3. #include 
    4. #include  // 用于随机睡眠时间
    5.  
    6. #define NUM_READERS 5
    7. #define NUM_WRITERS 3
    8.  
    9. pthread_rwlock_t rwlock;
    10. int global_resource = 0;
    11.  
    12. void* writer(void* arg) {
    13.     int thread_id = *(int*)arg;
    14.     while (1) {
    15.         // 模拟写操作
    16.         sleep(rand() % 3); // 随机睡眠时间
    17.  
    18.         // 加写锁
    19.         pthread_rwlock_wrlock(&rwlock);
    20.  
    21.         // 写操作
    22.         global_resource++;
    23.         printf("Writer %d writes: global_resource = %d\n", thread_id, global_resource);
    24.  
    25.         // 解锁
    26.         pthread_rwlock_unlock(&rwlock);
    27.     }
    28.     return NULL;
    29. }
    30.  
    31. void* reader(void* arg) {
    32.     int thread_id = *(int*)arg;
    33.     while (1) {
    34.         // 模拟读操作
    35.         sleep(rand() % 2); // 随机睡眠时间
    36.  
    37.         // 加读锁
    38.         pthread_rwlock_rdlock(&rwlock);
    39.  
    40.         // 读操作
    41.         printf("Reader %d reads: global_resource = %d\n", thread_id, global_resource);
    42.  
    43.         // 解锁
    44.         pthread_rwlock_unlock(&rwlock);
    45.     }
    46.     return NULL;
    47. }
    48.  
    49. int main() {
    50.     pthread_t writers[NUM_WRITERS], readers[NUM_READERS];
    51.     int writer_ids[NUM_WRITERS], reader_ids[NUM_READERS];
    52.     int i;
    53.  
    54.     // 初始化读写锁
    55.     pthread_rwlock_init(&rwlock, NULL);
    56.  
    57.     // 创建写线程
    58.     for (i = 0; i < NUM_WRITERS; ++i) {
    59.         writer_ids[i] = i + 1;
    60.         pthread_create(&writers[i], NULL, writer, &writer_ids[i]);
    61.     }
    62.  
    63.     // 创建读线程
    64.     for (i = 0; i < NUM_READERS; ++i) {
    65.         reader_ids[i] = i + 1;
    66.         pthread_create(&readers[i], NULL, reader, &reader_ids[i]);
    67.     }
    68.  
    69.     // 等待所有写线程结束
    70.     for (i = 0; i < NUM_WRITERS; ++i) {
    71.         pthread_join(writers[i], NULL);
    72.     }
    73.  
    74.     // 等待所有读线程结束
    75.     for (i = 0; i < NUM_READERS; ++i) {
    76.         pthread_join(readers[i], NULL);
    77.     }
    78.  
    79.     // 销毁读写锁
    80.     pthread_rwlock_destroy(&rwlock);
    81.  
    82.     return 0;
    83. }

    4. 信号量（Semaphore）

    信号量是由一个整型变量和相关的操作集合组成，用于控制对共享资源的访问。信号量可以看作是一个计数器，用于表示可用的资源数量，线程或进程在访问资源前必须首先获取信号量，访问结束后释放信号量。

    主要作用包括：

    • 同步：控制多个线程或进程的执行顺序，保证在某些条件下的有序执行。
    • 互斥：保证对共享资源的访问是排他的，避免多个线程或进程同时修改资源造成的数据不一致性问题。

    4.2相关操作函数

    4.2.1sem_init()

    初始化一个信号量 sem。

    1. int sem_init(sem_t *sem, int pshared, unsigned int value);
    2. 参数：
    3. sem_t *sem：指向要初始化的信号量的指针。
    4. int pshared：指定信号量是进程共享（非零）还是线程共享（零）。
    5. unsigned int value：信号量的初始值，表示可用资源的数量。
    6. 返回值：
    7. 成功：返回 0。
    8. 失败：返回 -1，并设置 errno 来指示错误原因。
    • 信号量初始化后需要通过 sem_destroy 函数进行清理。
    • 如果 pshared 是非零，则信号量可以在多个进程间共享，通常使用在进程间通信（IPC）的场景中。

    4.2.2sem_destroy()

    销毁一个已经初始化的信号量 sem。释放由信号量占用的资源，确保在信号量不再需要时调用。

    1. int sem_destroy(sem_t *sem);
    2. 参数：
    3. sem_t *sem：指向要销毁的信号量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回 -1，并设置 errno 来指示错误原因。

    4.2.3.sem_wait()

    对信号量 sem 进行 P 操作（等待操作）。

    1. int sem_wait(sem_t *sem);
    2. 参数：
    3. sem_t *sem：指向要操作的信号量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回 -1，并设置 errno 来指示错误原因。
    • 如果信号量的值大于 0，将其递减；否则阻塞当前线程，直到信号量的值大于 0。
    • 该函数执行时需要保证线程安全，通常与互斥锁结合使用以避免竞态条件。

    4.2.4sem_trywait()

    尝试对信号量 sem 进行 P 操作的非阻塞版本。与 sem_wait 不同的是，如果信号量的值为 0，立即返回而不阻塞线程。

    1. int sem_trywait(sem_t *sem);
    2. 参数：
    3. sem_t *sem：指向要操作的信号量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 如果信号量的值为 0，表示资源不可用，立即返回 -1（不阻塞），并设置 errno 为 EAGAIN。
    7. 其他失败情况返回 -1，并设置 errno 来指示错误原因。

    4.2.5sem_post()

    对信号量 sem 进行 V 操作（释放操作）。

    1. int sem_post(sem_t *sem);
    2. 参数：
    3. sem_t *sem：指向要操作的信号量的指针。
    4. 返回值：
    5. 成功：返回 0。
    6. 失败：返回 -1，并设置 errno 来指示错误原因。
    • 将信号量的值递增，如果有线程因等待该信号量而被阻塞，将会唤醒其中一个线程。
    • 释放操作通常在资源使用完毕后调用，通知其他线程可以继续访问该资源。

    4.2.6sem_getvalue()

    获取信号量 sem 的当前值。sem_getvalue 函数可以获取信号量的当前值，而无需对其进行修改。

    1. int sem_getvalue(sem_t *restrict sem, int *restrict sval);
    2. 参数：
    3. sem_t *restrict sem：指向要获取值的信号量的指针。
    4. int *restrict sval：用于存储信号量当前值的整型指针。
    5. 返回值：
    6. 成功：返回 0，并将当前信号量的值存储在 sval 中。
    7. 失败：返回 -1，并设置 errno 来指示错误原因。

    示例代码：

    使用信号量实现哲学家就餐问题

    信号量演示代码：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. #define NUM_THREADS 5
    8.  
    9. int shared_variable = 0;  // 共享的变量
    10. sem_t mutex;  // 互斥信号量
    11.  
    12. void *thread_function(void *arg) {
    13.     int thread_id = *((int *)arg);
    14.     int local_variable = 0;
    15.     
    16.     while (1) {
    17.         // 临界区开始
    18.         sem_wait(&mutex);  // 等待互斥信号量，保证互斥访问共享资源
    19.         local_variable = shared_variable;  // 读取共享变量到本地变量
    20.         local_variable++;  // 修改本地变量
    21.         sleep(rand() % 2);  // 模拟其他操作
    22.         shared_variable = local_variable;  // 写回共享变量
    23.         printf("线程 %d 执行后，共享变量的值为: %d\n", thread_id, shared_variable);
    24.         sem_post(&mutex);  // 释放互斥信号量
    25.         // 临界区结束
    26.         
    27.         sleep(rand() % 2 + 1);  // 模拟一段时间后再次操作
    28.     }
    29.     
    30.     pthread_exit(NULL);
    31. }
    32.  
    33. int main() {
    34.     pthread_t threads[NUM_THREADS];
    35.     int thread_ids[NUM_THREADS];
    36.     
    37.     // 初始化互斥信号量
    38.     sem_init(&mutex, 0, 1);  // 初始值为1，表示资源未被占用
    39.     
    40.     // 创建线程
    41.     for (int i = 0; i < NUM_THREADS; ++i) {
    42.         thread_ids[i] = i;
    43.         pthread_create(&threads[i], NULL, thread_function, (void *)&thread_ids[i]);
    44.     }
    45.     
    46.     // 等待线程结束
    47.     for (int i = 0; i < NUM_THREADS; ++i) {
    48.         pthread_join(threads[i], NULL);
    49.     }
    50.     
    51.     // 销毁信号量
    52.     sem_destroy(&mutex);
    53.     
    54.     return 0;
    55. }

  • 相关阅读:
    若依框架前端切换TagView时刷新问题
    Spring Boot实现文件上传功能
    BUUCTF msic 专题（125）[GUET-CTF2019]soul sipse
    matlab中的iddata函数的初步理解和使用程序举例
    C++_继承
    QT Model/View 编程：MVC模型视图编程：实例实现（二）
    #IIC 通信协议
    FlinkSQL自定义UDTF使用的四种方式
    【强化学习论文合集】NeurIPS-2021 强化学习论文
    JavaScript常用事件详解
  • 原文地址：https://blog.csdn.net/qq_42037383/article/details/140402387