Linux-笔记线程同步机制

P操作（Proberen）：也叫wait或down操作，表示请求资源。
- 对于计数信号量，P操作会将信号量的值减一，如果结果为负，进程将进入等待状态。
- 对于二元信号量，如果信号量值为0，进程将进入等待状态；如果为1，则设置为0，继续执行。
V操作（Verhogen）：也称为signal或up操作，表示释放资源。
- 对于计数信号量，V操作会将信号量的值加一，如果有进程在等待，将唤醒一个等待的进程。
- 对于二元信号量，将信号量设置为1，并唤醒一个等待的进程（如果有的话）。

无名信号量的操作函数

1、sem_init：初始化一个无名信号量

int sem_init(sem_t *sem, int pshared, unsigned int value);

sem_t sem;
if (sem_init(&sem, 0, 1) != 0) {
    perror("sem_init");
    exit(EXIT_FAILURE);
}

参数：
- sem：指向信号量对象的指针。
- pshared：指定信号量是否在进程间共享。0 表示用于线程间同步，非 0 表示用于进程间同步。
- value：信号量的初始值。
返回值：
- 成功返回 0，失败返回 -1 并设置 errno。

2、sem_destroy：销毁一个无名信号量。

int sem_destroy(sem_t *sem);

if (sem_destroy(&sem) != 0) {
    perror("sem_destroy");
    exit(EXIT_FAILURE);
}

参数：
- sem：指向要销毁的信号量对象的指针。
返回值：
- 成功返回 0，失败返回 -1 并设置 errno。

3、sem_wait：等待信号量，将信号量的值减1。如果信号量的值为0，则阻塞直到信号量的值大于0。

int sem_wait(sem_t *sem);

if (sem_wait(&sem) != 0) {
    perror("sem_wait");
    exit(EXIT_FAILURE);
}

参数：
- sem：指向信号量对象的指针。
返回值：
- 成功返回 0，失败返回 -1 并设置 errno。

4、sem_post：释放信号量，将信号量的值加1。如果有其他线程正在阻塞等待该信号量，则唤醒其中一个线程。

int sem_post(sem_t *sem);

if (sem_post(&sem) != 0) {
    perror("sem_post");
    exit(EXIT_FAILURE);
}

参数：
- sem：指向信号量对象的指针。
返回值：
- 成功返回 0，失败返回 -1 并设置 errno。

5、sem_trywait：尝试等待信号量。如果信号量的值大于0，将信号量的值减1并立即返回。如果信号量的值为0，则立即返回错误而不阻塞。

int sem_trywait(sem_t *sem);

if (sem_trywait(&sem) != 0) {
    if (errno == EAGAIN) {
        printf("信号量当前不可用\n");
    } else {
        perror("sem_trywait");
        exit(EXIT_FAILURE);
    }
}

参数：
- sem：指向信号量对象的指针。
返回值：
- 成功返回 0，失败返回 -1 并设置 errno。

6、sem_timedwait：在指定的时间内等待信号量。如果在指定时间内信号量的值变为正数，则将其减1并返回。如果超过指定时间，返回错误。

int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);

struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += 5; // 等待5秒

if (sem_timedwait(&sem, &ts) != 0) {
    if (errno == ETIMEDOUT) {
        printf("等待超时\n");
    } else {
        perror("sem_timedwait");
        exit(EXIT_FAILURE);
    }
}

参数：
- sem：指向信号量对象的指针。
- abs_timeout：指定的绝对超时时间。
返回值：
- 成功返回 0，失败返回 -1 并设置 errno。

例子

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

sem_t sem_g, sem_p;  // 定义两个信号量
char ch = 'a';

void *pthread_g(void *arg)  // 改变字符 ch 的值
{
	while (1)
	{
		sem_wait(&sem_g);  //第一次为0阻塞
		ch++;
		sleep(1);
		sem_post(&sem_p);  //加1
	}
}

void *pthread_p(void *arg)  // 打印字符 ch 的值
{
	while (1)
	{
		sem_wait(&sem_p); //非0，减一执行
		printf("%c", ch);
		fflush(stdout);
		sem_post(&sem_g); //为0，加一
	}
}

int main()
{
	pthread_t tid1, tid2;
	sem_init(&sem_g, 0, 0);  // 初始化信号量
	sem_init(&sem_p, 0, 1);  //sem_p先获得1，先执行

	pthread_create(&tid1, NULL, pthread_g, NULL);
	pthread_create(&tid2, NULL, pthread_p, NULL);

	pthread_join(tid1, NULL);
	pthread_join(tid2, NULL);

	return 0;
}

互斥锁（mutex）

互斥锁又叫互斥量，在对共享资源进行访问的时候可以进行上锁，访问结束后可以解锁。当有一个线程对互斥锁进行上锁后，其他线程也想对互斥锁进行上锁就会被阻塞，直到对互斥锁上锁的线程释放互斥锁为止。如果释放互斥锁时有一个以上的线程阻塞，那么这些阻塞的线程会被唤醒，它们都会尝试对互斥锁进行上锁，当有一个线程成功对互斥锁上锁之后，其它线程就不能再次上锁了，只能再次陷入阻塞，等待下一次解锁。

简单说，互斥量就是为了确保同一时间只有一个线程能够访问一个共享资源。

互斥锁的操作函数

1、pthread_mutex_init：初始化一个互斥锁。

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

pthread_mutex_t mutex;
if (pthread_mutex_init(&mutex, NULL) != 0) {
    perror("pthread_mutex_init");
    exit(EXIT_FAILURE);
}

参数：
- mutex：指向互斥锁对象的指针。
- attr：互斥锁属性。可以是 NULL，表示使用默认属性。
返回值：
- 成功返回 0，失败返回错误代码。

2、pthread_mutex_destroy：销毁一个互斥锁。

int pthread_mutex_destroy(pthread_mutex_t *mutex);

if (pthread_mutex_destroy(&mutex) != 0) {
    perror("pthread_mutex_destroy");
    exit(EXIT_FAILURE);
}

参数：
- mutex：指向要销毁的互斥锁对象的指针。
返回值：
- 成功返回 0，失败返回错误代码。

3、pthread_mutex_lock：锁定一个互斥锁。如果互斥锁已经被锁定，则阻塞直到互斥锁可用。

int pthread_mutex_lock(pthread_mutex_t *mutex);

if (pthread_mutex_lock(&mutex) != 0) {
    perror("pthread_mutex_lock");
    exit(EXIT_FAILURE);
}

参数：
- mutex：指向要锁定的互斥锁对象的指针。
返回值：
- 成功返回 0，失败返回错误代码。

4、pthread_mutex_trylock：尝试锁定一个互斥锁。如果互斥锁已经被锁定，则立即返回错误而不阻塞。

int pthread_mutex_trylock(pthread_mutex_t *mutex);

if (pthread_mutex_trylock(&mutex) != 0) {
    if (errno == EBUSY) {
        printf("互斥锁当前已被锁定\n");
    } else {
        perror("pthread_mutex_trylock");
        exit(EXIT_FAILURE);
    }
}

参数：
- mutex：指向要锁定的互斥锁对象的指针。
返回值：
- 成功返回 0，失败返回错误代码。

5、pthread_mutex_unlock：解锁一个互斥锁。

int pthread_mutex_unlock(pthread_mutex_t *mutex);

if (pthread_mutex_unlock(&mutex) != 0) {
    perror("pthread_mutex_unlock");
    exit(EXIT_FAILURE);
}

参数：
- mutex：指向要解锁的互斥锁对象的指针。
返回值：
- 成功返回 0，失败返回错误代码。

例子

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

#define NUM_ITERATIONS 1000000

int counter = 0;
pthread_mutex_t mutex;

void* increment(void* arg) {
    for (int i = 0; i < NUM_ITERATIONS; i++) {
        pthread_mutex_lock(&mutex);   // 加锁
        counter++;
        pthread_mutex_unlock(&mutex); // 解锁
    }
    return NULL;
}

void* decrement(void* arg) {
    for (int i = 0; i < NUM_ITERATIONS; i++) {
        pthread_mutex_lock(&mutex);   // 加锁
        counter--;
        pthread_mutex_unlock(&mutex); // 解锁
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;

    // 初始化互斥锁
    if (pthread_mutex_init(&mutex, NULL) != 0) {
        perror("pthread_mutex_init");
        exit(EXIT_FAILURE);
    }

    // 创建线程
    if (pthread_create(&thread1, NULL, increment, NULL) != 0) {
        perror("pthread_create");
        exit(EXIT_FAILURE);
    }
    if (pthread_create(&thread2, NULL, decrement, NULL) != 0) {
        perror("pthread_create");
        exit(EXIT_FAILURE);
    }

    // 等待线程完成
    if (pthread_join(thread1, NULL) != 0) {
        perror("pthread_join");
        exit(EXIT_FAILURE);
    }
    if (pthread_join(thread2, NULL) != 0) {
        perror("pthread_join");
        exit(EXIT_FAILURE);
    }

    // 销毁互斥锁
    if (pthread_mutex_destroy(&mutex) != 0) {
        perror("pthread_mutex_destroy");
        exit(EXIT_FAILURE);
    }

    // 输出结果
    printf("Final counter value: %d\n", counter);

    return 0;
}

条件变量（Condition Variables）

条件变量是用于线程同步的一种机制，通常与互斥锁（mutex）配合使用，是因为条件的检测是在互斥锁的保护下进行的，也就是说条件本身是由互斥锁保护的，线程在改变条件状态之前必须首先锁住互斥锁，不然就可能引发线程不安全的问题。

条件变量允许线程在某些条件不满足的情况下进行等待，并在条件满足时被唤醒。也就是说条件变量允许一个线程休眠（阻塞等待）直至获取到另一个线程的通知（收到信号）再去执行自己的操作。

条件变量的操作函数

1、pthread_cond_init：初始化条件变量。

int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

参数：
- cond: 指向条件变量的指针。
- attr: 条件变量属性。通常为NULL，使用默认属性。
返回值：成功返回0，失败返回错误码。

2、pthread_cond_destroy：摧毁条件变量

int pthread_cond_destroy(pthread_cond_t *cond);

参数：
- cond: 指向条件变量的指针。
返回值：成功返回0，失败返回错误码。

对于初始化与销毁操作，有以下问题需要注意：

1）在使用条件变量之前必须对条件变量进行初始化操作，使用 PTHREAD_COND_INITIALIZER 宏或者函数 pthread_cond_init()都行；

2）对已经初始化的条件变量再次进行初始化，将可能会导致未定义行为；

3）对没有进行初始化的条件变量进行销毁，也将可能会导致未定义行为；

4）对某个条件变量而言，仅当没有任何线程等待它时，将其销毁才是最安全的；

5）经 pthread_cond_destroy()销毁的条件变量，可以再次调用 pthread_cond_init()对其进行重新初始化。

条件变量的主要操作便是发送信号（signal）和等待。发送信号操作即是通知一个或多个处于等待状态的线程，某个共享变量的状态已经改变，这些处于等待状态的线程收到通知之后便会被唤醒，唤醒之后再检查条件是否满足，等待操作是指在收到一个通知前一直处于阻塞状态。

3、pthread_cond_wait：等待条件变量。此函数必须在持有互斥锁的情况下调用。

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

参数：
- cond: 指向条件变量的指针。
- mutex: 指向互斥锁的指针。函数内部会在等待时释放互斥锁，并在被唤醒后重新加锁。
返回值：成功返回0，失败返回错误码。

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

int pthread_cond_signal(pthread_cond_t *cond);

参数：
- cond: 指向条件变量的指针。
返回值：成功返回0，失败返回错误码。

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

int pthread_cond_broadcast(pthread_cond_t *cond);

参数：
- cond: 指向条件变量的指针。
返回值：成功返回0，失败返回错误码。

6、pthread_cond_timedwait：等待条件变量，带有超时功能。

int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);

参数：
- cond: 指向条件变量的指针。
- mutex: 指向互斥锁的指针。函数内部会在等待时释放互斥锁，并在被唤醒或超时后重新加锁。
- abstime: 绝对时间，用于指定等待超时时间。
返回值：成功返回0，超时返回ETIMEDOUT，失败返回其他错误码。

例子

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

static pthread_mutex_t mutex;
static pthread_cond_t cond;
static int g_avail = 0;

static void *consumer_thread(void *arg)
{
    for (;;) {
        pthread_mutex_lock(&mutex);
        while (0 >= g_avail)
            pthread_cond_wait(&cond, &mutex);

        while (0 < g_avail)
            g_avail--;

        pthread_mutex_unlock(&mutex);
    }

    return (void*)0;
}

int main(int argc, char *argv[]) {
    pthread_t tid;
    int ret;

    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);

    ret = pthread_create(&tid, NULL, consumer_thread, NULL);
    if (ret) {
        fprintf(stderr, "pthread_create error: %s\n", strerror(ret));
        exit(-1);
    }

    for (;;) {
        pthread_mutex_lock(&mutex);  //上锁
        g_avail++;                   //生产
        pthread_mutex_unlock(&mutex);//解锁
        pthread_cond_signal(&cond);  //向条件变量发送信号
    }

    exit(0);
}

自旋锁（Spinlock）

自旋锁（spinlock）是一种用于多线程编程的同步机制，用于保护共享资源，使同一时间只有一个线程可以访问该资源。与互斥锁不同，自旋锁在等待锁时不会使线程休眠，而是不断地检查锁的状态，直到获得锁。这种机制在短时间内需要高频率访问共享资源的情况下比较有效。

自旋锁的不足之处在于：自旋锁一直占用的 CPU，它在未获得锁的情况下，一直处于运行状态（自旋），所以占着 CPU，如果不能在很短的时间内获取锁，这无疑会使 CPU 效率降低。试图对同一自旋锁加锁两次必然会导致死锁，而试图对同一互斥锁加锁两次不一定会导致死锁。

自旋锁与互斥锁的区别

特性	自旋锁（Spinlock）	互斥锁（Mutex）
等待机制	忙等待，循环检查锁状态	睡眠等待，线程被挂起
CPU开销	高（忙等待消耗CPU）	低（等待时线程睡眠）
上下文切换	不会发生	可能发生
适用场景	锁持有时间短，多处理器系统	锁持有时间长，各类系统
复杂度	简单	复杂（需要操作系统调度支持）
死锁检测	一般没有自动检测机制	可以有自动检测机制

自旋锁的操作函数

1、spin_lock_init：初始化一个自旋锁。

int pthread_spin_init(pthread_spinlock_t *lock, int pshared);

static pthread_spinlock_t spin;//定义自旋锁
pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE);

参数：
- lock：指向 pthread_spinlock_t 类型的指针，用于存储初始化后的自旋锁。
- pshared：指定锁的共享性质，可以是 PTHREAD_PROCESS_PRIVATE 或 PTHREAD_PROCESS_SHARED。
返回值：
- 成功初始化返回 0，失败返回错误码。

2、pthread_spin_destroy：用于销毁自旋锁。

int pthread_spin_destroy(pthread_spinlock_t *lock);

static pthread_spinlock_t spin;
/* 销毁自旋锁 */
 pthread_spin_destroy(&spin);

参数：
- lock：指向 pthread_spinlock_t 类型的指针，指定要销毁的自旋锁。
返回值：
- 成功销毁返回 0，失败返回错误码。

3、pthread_spin_lock：用于获取自旋锁，如果自旋锁已经被其他线程持有，则当前线程会一直自旋等待直到获取锁为止。

int pthread_spin_lock(pthread_spinlock_t *lock);

static pthread_spinlock_t spin;//定义自旋锁
pthread_spin_lock(&spin); //自旋锁上锁

参数：
- lock：指向 pthread_spinlock_t 类型的指针，指定要获取的自旋锁。
返回值：
- 成功获取锁返回 0，失败返回错误码。

4、pthread_spin_trylock：用于尝试获取自旋锁，如果自旋锁已经被其他线程持有，则立即返回失败，不会进入自旋等待。

int pthread_spin_trylock(pthread_spinlock_t *lock);

参数：
- lock：指向 pthread_spinlock_t 类型的指针，指定要尝试获取的自旋锁。
返回值：
- 成功获取锁返回 0，失败返回 EBUSY（锁已经被持有）或其他错误码。

5、pthread_spin_unlock：用于释放自旋锁，允许其他线程继续获取该自旋锁。

int pthread_spin_unlock(pthread_spinlock_t *lock);

pthread_spin_unlock(&spin);//自旋锁解锁

参数：
- lock：指向 pthread_spinlock_t 类型的指针，指定要释放的自旋锁。
返回值：
- 成功释放锁返回 0，失败返回错误码。

例子

#include <stdio.h>
#include <pthread.h>
#include <unistd.h> // 提供 sleep 函数

pthread_spinlock_t lock;
int shared_variable = 0;

void* thread_func(void* arg) {
    for (int i = 0; i < 5; ++i) {
        pthread_spin_lock(&lock);
        shared_variable++;
        printf("Thread %ld: shared_variable = %d\n", (long)pthread_self(), shared_variable);
        pthread_spin_unlock(&lock);
        sleep(1); // 模拟耗时操作
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;

    // 初始化自旋锁
    pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE);

    // 创建线程
    pthread_create(&thread1, NULL, thread_func, NULL);
    pthread_create(&thread2, NULL, thread_func, NULL);

    // 等待线程结束
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    // 销毁自旋锁
    pthread_spin_destroy(&lock);

    return 0;
}

读写锁（Read-Write Lock）

读写锁是一种同步机制，允许多个线程同时读取共享数据，但在写数据时只允许一个线程访问。这种机制可以提高并发性，尤其是在读多写少的场景下。读写锁也叫做共享互斥锁。当读写锁是读模式锁住时，就可以说成是共享模式锁住。当它是写模式锁住时，就可以说成是互斥模式锁住。读写锁有三种状态，分别是读模式下的上锁状态、写模式下的上锁状态、不上锁状态。

读写锁两个规则：

1）当读写锁处于写加锁状态时，在这个锁被解锁之前，所有试图对这个锁进行加锁操作（不管是以读模式加锁还是以写模式加锁）的线程都会被阻塞。

2）当读写锁处于读加锁状态时，所有试图以读模式对它进行加锁的线程都可以加锁成功；但是任何以写模式对它进行加锁的线程都会被阻塞，直到所有持有读模式锁的线程释放它们的锁为止。

读写锁的操作函数

1、pthread_rwlock_init：初始化读写锁。

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

参数：
- rwlock: 指向读写锁的指针。
- attr: 读写锁属性。通常为NULL，使用默认属性。
返回值：成功返回0，失败返回错误码。

2、pthread_rwlock_destroy：销毁读写锁。

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

参数：
- rwlock: 指向读写锁的指针。
返回值：成功返回0，失败返回错误码。

3、pthread_rwlock_rdlock：获取读锁。如果有其他线程持有写锁，则调用线程将阻塞。

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

参数：
- rwlock: 指向读写锁的指针。
返回值：成功返回0，失败返回错误码。

4、pthread_rwlock_wrlock：获取写锁。如果有其他线程持有读锁或写锁，则调用线程将阻塞。

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

参数：
- rwlock: 指向读写锁的指针。
返回值：成功返回0，失败返回错误码。

5、pthread_rwlock_unlock：释放读锁或写锁。

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

参数：
- rwlock: 指向读写锁的指针。
返回值：成功返回0，失败返回错误码。

6、pthread_rwlock_tryrdlock：尝试获取读锁。如果读写锁不可用，函数不会阻塞并立即返回错误码。

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

参数：
- rwlock: 指向读写锁的指针。
返回值：成功返回0，失败返回错误码 EBUSY。

7、pthread_rwlock_trywrlock：尝试获取写锁。如果读写锁不可用，函数不会阻塞并立即返回错误码。

int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

参数：
- rwlock: 指向读写锁的指针。
返回值：成功返回0，失败返回错误码 EBUSY。

例子

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

static pthread_rwlock_t rwlock;
static int g_count = 0;

static void *read_thread(void *arg)
{
    int number = *((int*)arg);

    for (int i=0;i<10;i++) {
        pthread_rwlock_rdlock(&rwlock);
        printf("读线程%d, g_count = %d\n", number+1, g_count);
        pthread_rwlock_unlock(&rwlock);
        sleep(1);
    }    

    return (void*)0;
}

static void *write_thread(void *arg)
{
    int number = *((int*)arg);

    for (int i=0;i<10;i++) {
        pthread_rwlock_wrlock(&rwlock);
        printf("写线程%d, g_count = %d\n", number+1, g_count+=20);
        pthread_rwlock_unlock(&rwlock);
        sleep(1);
    }    

    return (void*)0;
}

static int nums[5] = {0, 1, 2, 3, 4};
int main(int argc, char **argv) 
{
    pthread_t tid[10];
    int j;

    /* 对读写锁进行初始化 */
    pthread_rwlock_init(&rwlock, NULL);
    
    /* 创建 5 个读 g_count 变量的线程 */
    for (j = 0; j < 5; j++)
    pthread_create(&tid[j], NULL, read_thread, &nums[j]);
    
    /* 创建 5 个写 g_count 变量的线程 */
    for (j = 0; j < 5; j++)
    pthread_create(&tid[j+5], NULL, write_thread, &nums[j]);
    
    /* 等待线程结束 */
    for (j = 0; j < 10; j++)
    pthread_join(tid[j], NULL);//回收线程
    
    /* 销毁自旋锁 */
    pthread_rwlock_destroy(&rwlock);
    
    exit(0);
}

屏障（Barrier）

屏障是一种同步机制，用于协调多个线程（或进程）在程序执行的某个点上相互等待，直到所有参与的线程都到达这个同步点后才继续执行。可以把它想象成一个关卡，所有线程必须在关卡处等待，直到所有线程都到达关卡，然后它们才能继续执行后续的代码。

其工作原理为：

1）定义一个屏障点：在程序中指定一个点，所有线程在此点前都会阻塞等待其他线程到达。

2）线程等待：每个线程在到达屏障点时调用等待函数，阻塞自己。

3）同步：当所有指定的线程都到达屏障点时，屏障被“解除”，所有被阻塞的线程同时继续执行。

屏障的操作函数

1、pthread_barrier_init：初始化屏障

int pthread_barrier_init(pthread_barrier_t *restrict barrier,
                         const pthread_barrierattr_t *restrict attr,
                         unsigned count);

barrier：指向屏障对象的指针。
attr：屏障属性，通常为NULL。
count：需要等待的线程数量。

返回值：成功返回0，失败返回错误码。

2、pthread_barrier_wait：等待屏障函数，也就是设置的等待点。

int pthread_barrier_wait(pthread_barrier_t *barrier);

barrier：指向屏障对象的指针。

返回值：成功返回0或PTHREAD_BARRIER_SERIAL_THREAD，失败返回错误码。

3、pthread_barrier_destroy：销毁屏障

int pthread_barrier_destroy(pthread_barrier_t *barrier);

barrier：指向屏障对象的指针。

返回值：成功返回0，失败返回错误码。

例子

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

// 定义屏障对象
pthread_barrier_t barrier;

// 线程函数
void* thread_function(void* arg) {
    int thread_num = *((int*)arg);
    printf("Thread %d reached the barrier\n", thread_num);

    // 线程在这里等待，直到所有线程都到达屏障
    int res = pthread_barrier_wait(&barrier);
    if (res == PTHREAD_BARRIER_SERIAL_THREAD) {
        printf("Thread %d is the serial thread\n", thread_num);
    } else if (res != 0) {
        perror("pthread_barrier_wait");
        exit(EXIT_FAILURE);
    }

    printf("Thread %d passed the barrier\n", thread_num);
    return NULL;
}

int main() {
    const int NUM_THREADS = 5;
    pthread_t threads[NUM_THREADS];
    int thread_nums[NUM_THREADS];

    // 初始化屏障，等待的线程数为NUM_THREADS
    if (pthread_barrier_init(&barrier, NULL, NUM_THREADS) != 0) {
        perror("pthread_barrier_init");
        exit(EXIT_FAILURE);
    }

    // 创建多个线程
    for (int i = 0; i < NUM_THREADS; i++) {
        thread_nums[i] = i + 1;
        if (pthread_create(&threads[i], NULL, thread_function, &thread_nums[i]) != 0) {
            perror("pthread_create");
            exit(EXIT_FAILURE);
        }
    }

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

    // 销毁屏障
    if (pthread_barrier_destroy(&barrier) != 0) {
        perror("pthread_barrier_destroy");
        exit(EXIT_FAILURE);
    }

    return 0;
}

注：代码中在线程中有一个判断如下，这是为了判断哪个线程是“串行线程”，所谓 “串行线程”就是在使用屏障机制时，所有到达屏障的线程在被解除阻塞后，会同时继续执行。但是，有一个线程会被选为“串行线程”（serial thread）。这个线程可以用于执行一些需要单独处理的操作，例如某些需要在所有线程继续之前完成的一次性初始化操作。

    if (res == PTHREAD_BARRIER_SERIAL_THREAD) {
        printf("Thread %d is the serial thread\n", thread_num);
    } else if (res != 0) {
        perror("pthread_barrier_wait");
        exit(EXIT_FAILURE);
    }

如运行的结果，可看出线程 5 为 “串行线程”，它是所有线程到底屏障点后第一个运行的线程。