Unix环境高级编程-学习-08-多线程之自旋锁与屏障

已于 2024-04-10 17:01:34 修改
阅读量763 收藏 21
点赞数 25
分类专栏： # Unix环境高级编程-学习 文章标签： 学习 开发语言 c语言 unix visual studio code
于 2024-03-25 17:17:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45111959/article/details/136941620
版权

目录

一、多线程相关文章链接

二、自由抒发

1、自旋锁

2、屏障

三、函数介绍

 1、pthread_spin_init

（1）声明

（2）作用

（3）参数

（4）返回值

（5）注意点

（6）宏

  2、pthread_spin_destroy

（1）声明

（2）作用

（3）参数

（4）返回值

（5）注意点

（6）宏

  3、pthread_spin_lock

（1）声明

（2）作用

（3）参数

（4）返回值

（5）注意点

（6）宏

  4、pthread_spin_trylock

（1）声明

（2）作用

（3）参数

（4）返回值

（5）注意点

（6）宏

  5、pthread_spin_unlock

（1）声明

（2）作用

（3）参数

（4）返回值

（5）注意点

（6）宏

  6、pthread_barrier_init

（1）声明

（2）作用

（3）参数

（4）返回值

（5）注意点

（6）宏

   7、pthread_barrier_destroy

（1）声明

（2）作用

（3）参数

（4）返回值

（5）注意点

（6）宏

   8、pthread_barrierattr_init

（1）声明

（2）作用

（3）参数

（4）返回值

（5）注意点

（6）宏

   9、pthread_barrierattr_destroy

（1）声明

（2）作用

（3）参数

（4）返回值

（5）注意点

（6）宏

   9、pthread_barrierattr_getpshared

（1）声明

（2）作用

（3）参数

（4）返回值

（5）注意点

（6）宏

    10、pthread_barrierattr_setpshared

（1）声明

（2）作用

（3）参数

（4）返回值

（5）注意点

（6）宏

     11、pthread_barrier_wait

（1）声明

（2）作用

（3）参数

（4）返回值

（5）注意点

（6）宏

四、锁测试验证

1、互斥锁测试Demo

2、自旋锁测试Demo

3、编译

4、互斥锁测试

 5、自旋锁测试

6、总结

五、屏障测试验证

1、Demo

2、编译

3、测试

一、多线程相关文章链接

 1、《Unix环境高级编程-学习-06-多线程之创建、销毁、属性获取和设置》

 2、《Unix环境高级编程-学习-07-多线程之互斥锁》

二、自由抒发

1、自旋锁

自旋锁的表现形式与互斥锁类似，拿不到锁会阻塞，但他们阻塞的原理却不同。举例说明：有10个人（核）每个人手上有一把假的钥匙，同时去换一把真的钥匙，拿到真钥匙的人可以开始自己的事情，其中一个人（核）用假钥匙换到真钥匙，其余的9个人（核）就一直和假钥匙交换，不能做其他事情，相当于在浪费CPU资源，而互斥锁拿不到锁，这个进程进入休眠状态，人（核）可以先去做其他事情，不会浪费太多CPU资源（有一个进程状态切换的消耗）。如果你的程序在访问临界资源的时间非常短，短暂的自旋资源消耗小于进程状态切换的消耗，我们就可以用自旋锁来实现互斥。

2、屏障

屏障是用户协调多线程并行工作的同步机制，类似于pthread_join等待所有线程结束，屏障只是少了结束这一步，线程还是可以继续使用。

例如给你一个这样的有向无环图，左上角是任务的起点，右下角是任务的终点，我们需要怎么去协同计算呢。

如果是单线程的我们通过拓扑排序得到的节点访问顺序是A->B->C->D->E->F->G->H->I->J->J->L，拓扑排序的相关方法可以参考之前的博客《数据结构与算法基础-学习-28-图之拓扑排序》，如果使用多线程的方法呢，首先主线程完成任务A，启动两个线程同时去做B和E，因为他们的前置条件任务A已经完成，所以可以平行，例如B先做完，需要等E做完，才能开三个线程同时去做C、F、I，那这个B等E完成，之后再去做其他事，这个同步行为就是屏障。


三、函数介绍

 1、pthread_spin_init

（1）声明

int pthread_spin_init(pthread_spinlock_t *__lock, int __pshared);

（2）作用

初始化自旋锁。

（3）参数

参数名描述
__lock需要初始化的自旋锁变量。
__pshared自旋锁的共享属性。

（4）返回值

名称描述
成功返回0。
失败返回错误码。

（5）注意点

如果pthread_spin_init()调用已经初始化过的自旋锁，结果是未定义。

如果在未初始化的情况下使用旋转锁，则结果是未定义的。

（6）宏

自旋锁变量进程共享属性值
宏描述
PTHREAD_PROCESS_PRIVATE只有同一个进程中的线程使用，默认值。
PTHREAD_PROCESS_SHARED可以多个进程的线程使用。

  2、pthread_spin_destroy

（1）声明

int pthread_spin_destroy(pthread_spinlock_t *lock);

（2）作用

销毁自旋锁。

（3）参数

参数名描述
lock需要销毁的自旋锁变量。

（4）返回值

名称描述
成功返回0。
失败返回错误码。

（5）注意点

当一个线程持有自旋锁时，调用pthread_spin_destroy()，结果是未定义的。

当自旋锁未初始化，调用pthread_spin_destroy()，结果是未定义的。

（6）宏

无。

  3、pthread_spin_lock

（1）声明

int pthread_spin_lock(pthread_spinlock_t *lock);

（2）作用

加自旋锁。

（3）参数

参数名描述
lock需要上锁的自旋锁变量。

（4）返回值

名称描述
成功返回0。
失败返回错误码。

（5）注意点

当一个线程已经持有自旋锁，继续调用pthread_spin_lock()，结果是未定义的。

调用pthread_spin_lock()加锁一个未初始化的自旋锁，结果是未定义的。

（6）宏

无。

  4、pthread_spin_trylock

（1）声明

int pthread_spin_trylock(pthread_spinlock_t *lock);

（2）作用

尝试加自旋锁，如果不可以立马获得锁，会返回宏EBUSY。

（3）参数

参数名描述
lock需要上锁的自旋锁变量。

（4）返回值

名称描述
成功返回0。
失败返回错误码。

（5）注意点

调用pthread_spin_trylock()加锁一个未初始化的自旋锁，结果是未定义的。

（6）宏

无。

  5、pthread_spin_unlock

（1）声明

int pthread_spin_unlock(pthread_spinlock_t *lock);

（2）作用

解锁自旋锁。

（3）参数

参数名描述
lock需要解锁的自旋锁变量。

（4）返回值

名称描述
成功返回0。
失败返回错误码。

（5）注意点

当前线程未持有自旋锁，继续调用pthread_spin_unlock()，结果是未定义的。

调用pthread_spin_unlock()解锁一个未初始化的自旋锁，结果是未定义的。

（6）宏

无。

  6、pthread_barrier_init

（1）声明

int pthread_barrier_init(pthread_barrier_t *__restrict__ __barrier, const pthread_barrierattr_t *__restrict__ __attr, unsigned int __count);

（2）作用

初始化线程屏障。

（3）参数

参数名描述
__barrier 需要初始化的屏障变量。
__attr屏障属性。
__count在所有线程继续运行之前，到达屏障的线程数。

（4）返回值

名称描述
成功返回0。
失败返回错误码。

（5）注意点

如果在未初始化的情况下使用屏障，则结果是未定义的。

如果调用 pthread_barrier_init（） 指定已初始化的屏障，则结果是未定义的。

（6）宏

无。

   7、pthread_barrier_destroy

（1）声明

int pthread_barrier_destroy(pthread_barrier_t *__barrier);

（2）作用

销毁线程屏障。

（3）参数

参数名描述
__barrier 需要销毁的屏障变量。

（4）返回值

名称描述
成功返回0。
失败返回错误码。

（5）注意点

如果pthread_barrier_destroy调用一个未初始化的屏障，结果是未定义的。

当任意线程在屏障上被锁住，此时调用pthread_barrier_destroy，结果是未定义的。

（6）宏

无。

   8、pthread_barrierattr_init

（1）声明

int pthread_barrierattr_init(pthread_barrierattr_t *__attr);

（2）作用

初始化线程屏障属性。

（3）参数

参数名描述
__attr 屏障属性。

（4）返回值

名称描述
成功返回0。
失败返回错误码。

（5）注意点

如果pthread_barrierattr_init调用一个未初始化的屏障属性，结果是未定义的。

（6）宏

无。

   9、pthread_barrierattr_destroy

（1）声明

int pthread_barrierattr_destroy(pthread_barrierattr_t *__attr);

（2）作用

销毁线程屏障属性。

（3）参数

参数名描述
__attr 屏障属性。

（4）返回值

名称描述
成功返回0。
失败返回错误码。

（5）注意点

无。

（6）宏

无。

   9、pthread_barrierattr_getpshared

（1）声明

int pthread_barrierattr_getpshared(const pthread_barrierattr_t *__restrict__ __attr, int *__restrict__ __pshared);

（2）作用

获取屏障变量进程共享属性值。

（3）参数

参数名描述
__attr 屏障属性。
__pshared获取到的屏障变量进程共享属性值。

（4）返回值

名称描述
成功返回0。
失败返回错误码。

（5）注意点

无。

（6）宏

宏描述
PTHREAD_PROCESS_PRIVATE只有同一个进程中的线程使用，默认值。
PTHREAD_PROCESS_SHARED可以多个进程的线程使用。

    10、pthread_barrierattr_setpshared

（1）声明

int pthread_barrierattr_setpshared(pthread_barrierattr_t *__attr, int __pshared);

（2）作用

设置屏障变量进程共享属性值。

（3）参数

参数名描述
__attr 屏障属性。
__pshared设置的屏障变量进程共享属性值。

（4）返回值

名称描述
成功返回0。
失败返回错误码。

（5）注意点

无。

（6）宏

宏描述
PTHREAD_PROCESS_PRIVATE只有同一个进程中的线程使用，默认值。
PTHREAD_PROCESS_SHARED可以多个进程的线程使用。

     11、pthread_barrier_wait

（1）声明

int pthread_barrier_wait(pthread_barrier_t *__barrier);

（2）作用

屏障等待其他线程达到。

（3）参数

参数名描述
__barrier 需要设置的屏障锁属性变量。

（4）返回值

名称描述
成功返回0。
失败返回错误码。

（5）注意点

无。

（6）宏

宏描述
PTHREAD_BARRIER_SERIAL_THREAD任意一个线程返回PTHREAD_BARRIER_SERIAL_THREAD后，其他线程返回0，可以做为主线程来看，之后可以做其他事情。

四、锁测试验证

10个线程对全局变量进行累加，和为600000，表示测试正常。

我这边只是对于线程、线程属性、互斥锁、互斥锁属性做了简单封装，方便使用，如果大家感兴趣的话，可以在博客下面留言，我后面找一章分享出来。

1、互斥锁测试Demo

#include "MyThread.h"

#define THRD_ARRAY_LEN 10
#define SUM_VAL        (600000 / THRD_ARRAY_LEN)

int GlobalCnt = 0;

void* TestFunc(void* Arg)
{
    int i;
    OneThrdMutexSt *Mutex = (OneThrdMutexSt *)Arg;

    for ( i = 0; i < SUM_VAL; i++)
    {
        if (THRD_MUTEX_LOCK_F(Mutex) == SUCCESS_FLAG)
        {
            GlobalCnt++;
            THRD_MUTEX_UNLOCK_F(Mutex);
        }        
    }

    THRD_EXIT(SUCCESS_FLAG);
}

Status main()
{
    OneThrdMutexSt  *Mutex         = NULL;
    OneThrdSt       **ThrdArray    = (OneThrdSt **)MyMalloc(sizeof(OneThrdSt *) * THRD_ARRAY_LEN);
    int             i;
    void            *ThrdExitState = NULL;

    OneThrdMutexCreate(&Mutex,
                      PTHREAD_PROCESS_PRIVATE,
                      //PTHREAD_MUTEX_ERRORCHECK,
                      PTHREAD_MUTEX_NORMAL,
                      PTHREAD_MUTEX_ROBUST,
                      0,
                      0);

    for ( i = 0; i < THRD_ARRAY_LEN; i++)
    {
        OneThrdCreate(&(ThrdArray[i]), 
                      PTHREAD_CREATE_JOINABLE,
                      PTHREAD_STACK_MIN, 
                      ONE_PAGE_MEM_SIZE,
                      TestFunc, 
                      Mutex);
    }

    for ( i = 0; i < THRD_ARRAY_LEN; i++)
    {
        ThrdWait(ThrdArray[i]->ThreadId, &ThrdExitState);
        LogFormat(Debug,"ThrdExitState      : %ld.\n",(long)ThrdExitState);
        OneThrdFree(&(ThrdArray[i]));
    }

    OneThrdMutexFree(&Mutex);

    free(ThrdArray);
    ThrdArray = NULL;

    LogFormat(Info,"GlobalCnt          : %d.\n",GlobalCnt);

    return SUCCESS_FLAG;
}

2、自旋锁测试Demo

#include "MyThread.h"

#define THRD_ARRAY_LEN 10
#define SUM_VAL        (600000 / THRD_ARRAY_LEN)

int                 GlobalCnt = 0;
pthread_spinlock_t  SpinLock;

void* TestFunc(void* Arg)
{
    int                i;

    for ( i = 0; i < SUM_VAL; i++)
    {
        if (ThrdSpinLock(&SpinLock) == SUCCESS_FLAG)
        {
            GlobalCnt++;
            ThrdSpinUnLock(&SpinLock);
        }        
    }

    THRD_EXIT(SUCCESS_FLAG);
}

Status main()
{
    OneThrdSt           **ThrdArray    = (OneThrdSt **)MyMalloc(sizeof(OneThrdSt *) * THRD_ARRAY_LEN);
    int                 i;
    void                *ThrdExitState = NULL;

    ThrdSpinInit(&SpinLock, PTHREAD_PROCESS_PRIVATE);

    for ( i = 0; i < THRD_ARRAY_LEN; i++)
    {
        OneThrdCreate(&(ThrdArray[i]), 
                      PTHREAD_CREATE_JOINABLE,
                      PTHREAD_STACK_MIN, 
                      ONE_PAGE_MEM_SIZE,
                      TestFunc, 
                      NULL);
    }

    for ( i = 0; i < THRD_ARRAY_LEN; i++)
    {
        ThrdWait(ThrdArray[i]->ThreadId, &ThrdExitState);
        LogFormat(Debug,"ThrdExitState      : %ld.\n",(long)ThrdExitState);
        OneThrdFree(&(ThrdArray[i]));
    }

    ThrdSpinDstry(&SpinLock);

    free(ThrdArray);
    ThrdArray = NULL;

    LogFormat(Info,"GlobalCnt          : %d.\n",GlobalCnt);

    return SUCCESS_FLAG;
}

3、编译

[gbase@czg2 Pthread]$ make
gcc -Wall -Wextra -O3 -std=gnu11  TestSpin.c -o TestSpin -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/Log/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/Pthread/ -L /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/Make/Libs/ -L /usr/lib64/ -l PublicFunction -l Log -l MyThread
TestSpin.c: 在函数‘TestFunc’中:
TestSpin.c:9:22: 警告：未使用的参数‘Arg’ [-Wunused-parameter]
 void* TestFunc(void* Arg)
                      ^
gcc -Wall -Wextra -O3 -std=gnu11  TestMutex.c -o TestMutex -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/Log/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/Pthread/ -L /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/Make/Libs/ -L /usr/lib64/ -l PublicFunction -l Log -l MyThread

4、互斥锁测试

测试三组，都在68毫秒左右。

[gbase@czg2 Pthread]$ perf stat -e page-faults ./TestMutex
2024-03-25 09:42:49-P[4622]-T[140504432363328]-[Info ]-GlobalCnt          : 600000.

 Performance counter stats for './TestMutex':

               249      page-faults:u                                               

       0.068061253 seconds time elapsed

       0.060074000 seconds user
       0.074329000 seconds sys


[gbase@czg2 Pthread]$ perf stat -e page-faults ./TestMutex
2024-03-25 09:42:51-P[4642]-T[140690703296320]-[Info ]-GlobalCnt          : 600000.

 Performance counter stats for './TestMutex':

               249      page-faults:u                                               

       0.064127278 seconds time elapsed

       0.047671000 seconds user
       0.076923000 seconds sys


[gbase@czg2 Pthread]$ perf stat -e page-faults ./TestMutex
2024-03-25 09:42:52-P[4661]-T[139921704650560]-[Info ]-GlobalCnt          : 600000.

 Performance counter stats for './TestMutex':

               249      page-faults:u                                               

       0.068365957 seconds time elapsed

       0.065637000 seconds user
       0.067688000 seconds sys

 5、自旋锁测试

测试三组，都在十几到二十毫秒左右。

[gbase@czg2 Pthread]$ perf stat -e page-faults ./TestSpin
2024-03-25 09:44:09-P[4721]-T[139990554580800]-[Info ]-GlobalCnt          : 600000.

 Performance counter stats for './TestSpin':

               248      page-faults:u                                               

       0.017746978 seconds time elapsed

       0.027653000 seconds user
       0.004424000 seconds sys


[gbase@czg2 Pthread]$ perf stat -e page-faults ./TestSpin
2024-03-25 09:44:11-P[4748]-T[139808353724224]-[Info ]-GlobalCnt          : 600000.

 Performance counter stats for './TestSpin':

               248      page-faults:u                                               

       0.026674296 seconds time elapsed

       0.048756000 seconds user
       0.002321000 seconds sys


[gbase@czg2 Pthread]$ perf stat -e page-faults ./TestSpin
2024-03-25 09:44:12-P[4767]-T[140348668368704]-[Info ]-GlobalCnt          : 600000.

 Performance counter stats for './TestSpin':

               248      page-faults:u                                               

       0.022916708 seconds time elapsed

       0.041160000 seconds user
       0.003087000 seconds sys

6、总结

上面的验证结果为自旋锁效果远高于互斥锁，但这只能说明在操作临界资源时间短的情况下是自旋锁效率高，也就是自旋锁短暂空耗CPU的消耗小于互斥锁进程状态切换的消耗。大家可以自己写一个另一种情况下的Demo，实验一下是不是这么回事。

五、屏障测试验证

实现内容为：每个线程累加，都到达屏障后，进行加和。

1、Demo

#include "MyThread.h"

#define THRD_ARRAY_LEN 3
#define SUM_VAL        (900 / THRD_ARRAY_LEN)

typedef struct TestSt
{
    int                 GlobalArray[THRD_ARRAY_LEN];
    int                 ThrdIdx;
    OneThrdBarrierSt    *Barrier;
    pthread_spinlock_t  SpinLock;
}TestSt;

void* TestFunc(void* Arg)
{
    TestSt* St = (TestSt*)Arg;

    if (ThrdSpinLock(&(St->SpinLock)) == FAIL_FLAG)
    {
        THRD_EXIT(FAIL_FLAG);
    }
    int Index = St->ThrdIdx;
    (St->ThrdIdx)++;
    ThrdSpinUnLock(&(St->SpinLock));

    int i;
    for ( i = 0; i < SUM_VAL; i++)
    {
        St->GlobalArray[Index]++;
    }

    THRD_BARRIER_WAIT_F(St->Barrier);

    THRD_EXIT(SUCCESS_FLAG);
}

Status main()
{
    OneThrdSt           **ThrdArray    = (OneThrdSt **)MyMalloc(sizeof(OneThrdSt *) * THRD_ARRAY_LEN);
    int                 i;
    void                *ThrdExitState = NULL;
    TestSt              St;
    int                 SumVal         = 0;

    St.ThrdIdx = 0;

    ThrdSpinInit(&(St.SpinLock), PTHREAD_PROCESS_PRIVATE);
    OneThrdBarrierCreate(&(St.Barrier), PTHREAD_PROCESS_PRIVATE, THRD_ARRAY_LEN + 1);

    for ( i = 0; i < THRD_ARRAY_LEN; i++)
    {
        St.GlobalArray[i] = 0;
        OneThrdCreate(&(ThrdArray[i]), 
                      PTHREAD_CREATE_JOINABLE,
                      PTHREAD_STACK_MIN, 
                      ONE_PAGE_MEM_SIZE,
                      TestFunc, 
                      &St);
    }

    THRD_BARRIER_WAIT_F(St.Barrier);

    for ( i = 0; i < THRD_ARRAY_LEN; i++)
    {
        SumVal += St.GlobalArray[i];
    }

    for ( i = 0; i < THRD_ARRAY_LEN; i++)
    {
        ThrdWait(ThrdArray[i]->ThreadId, &ThrdExitState);
        LogFormat(Debug,"ThrdExitState      : %ld.\n",(long)ThrdExitState);
        OneThrdFree(&(ThrdArray[i]));
    }

    ThrdSpinDstry(&(St.SpinLock));
    OneThrdBarrierFree(&(St.Barrier));

    free(ThrdArray);
    ThrdArray = NULL;

    LogFormat(Info,"SumVal             : %d.\n",SumVal);

    return SUCCESS_FLAG;
}

2、编译

gcc -Wall -Wextra -O3 -std=gnu11  TestBarrier.c -o TestBarrier -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/Log/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/Pthread/ -L /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/Make/Libs/ -L /usr/lib64/ -l PublicFunction -l Log -l MyThread
gcc -Wall -Wextra -O3 -std=gnu11  TestSpin.c -o TestSpin -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/Log/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/Pthread/ -L /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/Make/Libs/ -L /usr/lib64/ -l PublicFunction -l Log -l MyThread
TestSpin.c: 在函数‘TestFunc’中:
TestSpin.c:9:22: 警告：未使用的参数‘Arg’ [-Wunused-parameter]
 void* TestFunc(void* Arg)
                      ^
gcc -Wall -Wextra -O3 -std=gnu11  TestMutex.c -o TestMutex -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/Log/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/Pthread/ -L /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/Make/Libs/ -L /usr/lib64/ -l PublicFunction -l Log -l MyThread

3、测试

[gbase@czg2 Pthread]$ perf stat -e page-faults ./TestBarrier
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdSpinInit       : OK, SharedVal   : PTHREAD_PROCESS_PRIVATE.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-BarrierAttrInit    : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-BarrierAttrSetShrd : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdBarrierInit    : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-BarrierAttrGetShrd : OK, SharedVal   : PTHREAD_PROCESS_PRIVATE.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-BarrierAttrDstry   : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-BarrierCreate      : OK, Cnt : 4.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdAttrInit       : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-SetDetachState     : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-SetStackSize       : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-SetGuardSize       : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdCreate         : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-GetDetachState     : OK, DetachState : PTHREAD_CREATE_JOINABLE.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-GetStackSize       : OK, StackSize   : 16384.
2024-03-25 16:03:05-P[12071]-T[140175572850432]-[Debug]-ThrdSpinLock       : OK.
2024-03-25 16:03:05-P[12071]-T[140175572850432]-[Debug]-ThrdSpinUnLock     : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-GetGuardSize       : OK, GuardSize   : 4096.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdAttrDestroy    : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-OneThrdCreate      : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdAttrInit       : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-SetDetachState     : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-SetStackSize       : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-SetGuardSize       : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdCreate         : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-GetDetachState     : OK, DetachState : PTHREAD_CREATE_JOINABLE.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-GetStackSize       : OK, StackSize   : 16384.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-GetGuardSize       : OK, GuardSize   : 4096.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdAttrDestroy    : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-OneThrdCreate      : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdAttrInit       : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-SetDetachState     : OK.
2024-03-25 16:03:05-P[12071]-T[140175572829952]-[Debug]-ThrdSpinLock       : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-SetStackSize       : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-SetGuardSize       : OK.
2024-03-25 16:03:05-P[12071]-T[140175572829952]-[Debug]-ThrdSpinUnLock     : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdCreate         : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-GetDetachState     : OK, DetachState : PTHREAD_CREATE_JOINABLE.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-GetStackSize       : OK, StackSize   : 16384.
2024-03-25 16:03:05-P[12071]-T[140175572809472]-[Debug]-ThrdSpinLock       : OK.
2024-03-25 16:03:05-P[12071]-T[140175572809472]-[Debug]-ThrdSpinUnLock     : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-GetGuardSize       : OK, GuardSize   : 4096.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdAttrDestroy    : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-OneThrdCreate      : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdBarrierWait    : OK, All threads arrive at the barrier.
2024-03-25 16:03:05-P[12071]-T[140175572829952]-[Debug]-ThrdBarrierWait    : OK.
2024-03-25 16:03:05-P[12071]-T[140175572850432]-[Debug]-ThrdBarrierWait    : OK.
2024-03-25 16:03:05-P[12071]-T[140175572809472]-[Debug]-ThrdBarrierWait    : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdWait           : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdExitState      : 0.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-OneThrdFree        : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdWait           : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdExitState      : 0.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-OneThrdFree        : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdWait           : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdExitState      : 0.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-OneThrdFree        : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdSpinDstry      : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-ThrdBarrierDstry   : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Debug]-OneThrdBarrierFree : OK.
2024-03-25 16:03:05-P[12071]-T[140175572858688]-[Info ]-SumVal             : 900.

 Performance counter stats for './TestBarrier':

               240      page-faults:u                                               

       0.003126995 seconds time elapsed

       0.001257000 seconds user
       0.001257000 seconds sys

阳光九叶草LXGZXJ
关注
  • 25
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
反省：pthread_barrier_init(),pthread_barrier_destroy()和pthread_barrier_wait()
亚瑟王的回音
01-11 2164
#include int pthread_barrier_destroy(pthread_barrier_t *barrier); int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, int count); int pthrea
C#多线程编程中的锁系统（四）：自旋锁
01-20
二：自旋锁示例 三：SpinLock 四：继续SpinLock 五：总结 一：基础 内核锁：基于内核对象构造的锁机制，就是通常说的内核构造模式。用户模式构造和内核模式构造  优点：cpu利用最大化。它发现资源被锁住，请求就...
第七章_线程 : 线程属性、同步属性
matafeiyanll的博客
12-13 263
线程属性 默认属性可以解决大多数情况，但是如果对性能有更高的要求，就可以通过修改线程属性，降低线程栈的大小，来减少内存的使用。 设置线程属性的结构体： typedef struct { int detachstate; //线程分离状态 int schedpolicy; //线程调度策略 struct sched_param schedparam; //线程的调度参数 int inheritsched; //线程的继承性 int scope; //线程的作用
屏障
u014325402的博客
10-23 347
屏障： 屏障（barrier）是用户协调多个线程并行工作的同步机制。屏障允许每个线程等待，直到所有的合作线程都达到某一点，然后从该点继续执行。 屏障属性: 可以通过pthread_barrierattr_setpshared设置屏障属性来控制屏障的使用范围。 屏障属性值: PTHREAD_PROCESS_SHARED: 在多进程中的多线程 PTHREAD_PROCESS_PRIVATE：
pthread_barrier_init,pthread_barrier_wait,pthread_barrier_destroy简介
ljclx1748的专栏
12-30 2365
pthread_barrier_init,pthread_barrier_wait,pthread_barrier_destroy简介 pthread_barrier 系列函数在中定义，用于多线程的同步，它包含三个函数：       --pthread_barrier_init()       --pthread_barrier_wait()       --pthread_bar
C/C++多线程编程：屏障
m0_61243666的博客
07-01 405
UNIX、Linux环境下多线程编程：屏障，posix标准。C库编程适用于嵌入式、C/C++服务器开发。
JAVA并发编程实践-线程安全-学习笔记
07-20
在Java并发编程中，线程安全是一个至关重要的概念，它涉及到多线程环境下对共享数据的正确管理和访问。线程安全意味着当多个线程同时访问一个对象或数据时，对象的状态能够保持一致性和完整性，不会因为并发导致数据...
多线程并发编程-同步与互斥-原⼦变量-并发和⽆锁 数据结构
最新发布
12-30
线程同步和互斥是多线程编程的核心技术之一。信号灯、互斥量、自旋锁和条件变量等都是实现线程同步和互斥的机制。线程同步和互斥的机制可以通过原子变量来实现。 5.3 线程同步和互斥 线程同步和互斥是多线程编程的...
ZYNQ 7010-7020实现自旋锁测试（Linux驱动）.zip
03-21
自旋锁是多线程编程中的一个关键概念，尤其是在实时操作系统和嵌入式系统中。它是一种同步机制，用于保护共享资源免受并发访问。在Linux内核中，自旋锁用于短暂的、非阻塞的锁定，确保只有一个线程可以访问特定的...
Linux下(屏障)barrier同步线程实例
paradox_1_0的博客
06-15 1441
1.API详解 屏障(barrier)是协调多个线程并行工作的同步机制。屏障允许每个线程等待，知道所有的合并线程都到达某一点，然后从该点继续执行。可以看到，pthread_join函数就是一种屏障，但屏障的概念更加广泛，其允许任意数量的线程等待，直到所有线程完成处理工作阻塞在预先设置的点(也就是调用pthread_barrier_wait函数的地方),线程不需要退出。所有线程到达barrier后...
屏障（UNIX环境高级编程笔记）
The_perfect_world的博客
04-21 339
  屏障（barrier）是用户协调多个线程并行工作的同步机制。屏障允许每个线程等待，直到所有的合作线程都到达某一点，然后从该点继续执行。   屏障允许任意数量的线程等待，知道所有的线程完成处理工作，而线程不需要退出。所有线程到达屏障之后可以接着工作。   可以使用pthread_barrier_init函数对屏障进行初始化，用pthread_barrier_destroy函数进行反初始化。 ...
UNIX环境高级编程
yhc166188的博客
07-12 1835
I/O 文件系统 进程 线程 进程间通信 一.文件I/O三.标准I/O库八.高级I/O 二.文件和目录 四.进程环境五.进程控制 六.线程七.线程控制 九.进程间通信十.信号 * [一.文件I/O](#一文件io) - [1.文件描述符](#1文件描述符) - [2.相关调用](#2相关调用) + [2.1 打开文件](#21-打...
UNIX环境高级编程——线程
qq_38154295的博客
05-13 697
UNIX环境高级编程——线程
pthread_barrier_init,pthread_barrier_wait简介
diaoju3333的博客
04-17 146
http://blog.csdn.net/qq405180763/article/details/23919191 pthread_barrier系列函数在<pthread.h>中定义，用于多线程的同步，它包含三个函数： --pthread_barrier_init() --pthread_barrier_wait() --pth...
【PTHREAD】线程互斥与同步之栅栏
zhy29563
09-04 409
【PTHREAD】线程互斥与同步之栅栏
线程属性总结
u011878172的专栏
03-10 587
1.    读写锁属性2.    条件变量属性3.    barrier属性它们都具有相同的属性 ： PTHREAD_PROCESS_PRIVATE; PTHREAD_PROCESS_SHARED#include&lt;stdio.h&gt; #include&lt;pthread.h&gt; int main() { pthread_barrierattr_t ba; int rc, sh...
APUE编程：65---线程处理（屏障属性：pthread_barrierattr_t）
董哥的黑板报
06-07 791
一、屏障属性结构体（pthread_barrierattr_t） pthread_barrierattr_t 二、屏障属性 进程共享：屏障只支持此属性，与互斥量的进程共享属性是相同的（互斥量见文章：https://blog.csdn.net/qq_41453285/article/details/90904833） 三、屏障属性结构体的初始化 #include <pthread.h&...
APUE编程：59---线程处理（互斥量属性：pthread_mutexattr_t）
董哥的黑板报
06-07 3757
文章待续 一、互斥量属性结构体（pthread_mutexattr_t） pthread_mutexattr_t 二、互斥量属性 进程共享属性（pshared） 进程共享属性是可选的。 可以通过检测系统是否定义了_POSIX_THREAD_PROCESS_SHARED符号来判断平台是否支持进程共享属性。也可以把_SC_THREAD_PORCESS_SHARED参数传给s...
Pthread API总结
Station of GoGdizzY
11-14 3319
Pthread API 函数名 说明 pthread_atfork fork前后的处理函数，一般不建议多线程下进行fork，见http://blog.csdn.net/anxuegang/article/details/66584722 pthread_attr_getguardsizepthread_attr_setguardsize 堆栈保护区大小 PTHREAD_CR
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值