Linux下C语言多线程编程

一、多线程基本概念

多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理或同时多线程处理器。在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理” .(百度) 在单核CPU单线程的处理器上，对于多线程的处理方式，只能分时切换线程，每一个线程运行一个时间片然后被换出，在这种情况下，无须担心公共临界区的变量的竞争问题，相反在对核心CPU中就需要非常严格的关注临界区的数据竞争情况。如下图所示分别为单核心多核心的线程调度情况：

二、多线程基本API介绍

1. 在Linux环境下多线程编程头文件

#include <errno.h> // Error code head file(EBUSY,ETIMEDOUT)
#include <pthread.h> // Pthread head file

2. 基本线程相关函数

1. pthread_mutex_t g_mutex; // 临界区锁定义
2. pthread_mutex_init(g_mutex,NULL); // 锁初始化函数
3. pthread_cond_t g_cond; // 触发条件定义
4. pthread_cond_init(g_cond,NULL); // 初始化条件变量
5. int ret = pthread_mutex_lock(&g_mutex); // 获取锁，获取失败则阻塞在此函数直至获取到锁，失败返回错误代码EBUSY
6. pthread_mutex_unlock(&g_mutex); // 进行解锁，释放锁
7. ret = pthread_mutex_trylock(&g_mutex); // 尝试获取锁，若获取失败，则不阻塞直接跳过，返回值为锁繁忙EBUSY
8. ret = pthread_mutex_timedlock(&g_mutex ,&outtime); // 尝试在outtime时间段之内获取锁，若超时未获取则不阻塞，并返回ETIMEDOUT
10. pthread_cond_wait(g_cond,g_mutex); // 先对锁进行解锁，并且阻塞等待cond信号触发直至触发完成
11. ret = pthread_cond_timedwait(g_cond,g_mutex,&outtime); // 先对锁进行解锁，并且等待cond信号触发，若在截止时间之前未触发，则跳出函数，并返回ETIMEDOUT
12. pthread_cond_signal(g_cond); // 单一发出触发信号，触发等待队列中的第一个线程，假设您只对队列添加了一个工作作业。那么只需要唤醒一个工作程序线程(再唤醒其它线程是不礼貌的!)
13. pthread_cond_broadcast(g_cond); // 发出广播触发信号，通知唤醒等待队列中的所有线程
14. pthread_cond_destroy(g_cond); // 销毁条件变量，归还条件变量资源
15. pthread_t th1; // 定义线程对象，类似于进程的PID号
16. pthread_create(&th1,NULL,thread_func,NULL); // Create the Thread1 & Start the thread func.
17. pthread_join(th1,NULL); // Wait the Thread1 end.
18. 待补充！

如上所示为基本的多线程编程API，上述锁的API的实现包括了多种方式，基本都能够满足常见的锁需求，对应的每一个函数调用基本上都有int类型的返回值，一般返回的内容都包括在了error.h头文件中。

其中函数pthread_cond_wait、pthread_mutex_lock会阻塞线程直至获取到对应条件，而其他锁相关函数不会一直阻塞线程，从而能够满足其他的场景。

3. 阻塞时间outtime参数设置：

\* 如下是timespec结构体的具体类型，其中都是long型 *\
struct timespec
{
  __time_t tv_sec;    /* Seconds.  */
  __syscall_slong_t tv_nsec;    /* Nanoseconds.  */
}; 

timespec结构体可以精确到纳秒级别，包括了两个成员变量，分别为秒tv_sec以及纳秒tv_nsec；

具体在延迟阻塞中应用是，可以先获取系统当前时间，然后在当前时间的基础上增加线程阻塞延迟增量，然后通过指针形参传递给对应的线程阻塞函数即可，详参见下：

#include <time.h> // 需要包含时间头文件
long wt_ms; // 需要延迟阻塞的时间
struct timespec outtime; // Defination定义
clock_gettime(CLOCK_REALTIME, &outtime); // Get the current time.(获取当前系统时间，注意一定要用CLOCK_REALTIME来获取系统时间)

/****************************************
*** 开始设置阻塞延迟时间点，在下个时间点触发 ***
****************************************/

outtime.tv_sec += wt_ms / 1000; // 毫秒换算秒
time_ns = outtime.tv_nsec + (wt_ms % 1000) * 1000000; // 多出的换算成纳秒
if(time_ns >= 1000000000){ // 溢出当前时间则需要判断是否进位
    outtime.tv_sec++; // 进位
    outtime.tv_nsec = time_ns - 1000000000; // 计算进位后余
}else{
    outtime.tv_nsec = time_ns; // 无需进位直接赋值即可
}
ret = pthread_mutex_timedlock(&g_mutex ,&outtime); // 阻塞延迟一段时间，然后返回相关代码给ret.

上述代码将outtime参数阻塞延迟时间传递给了pthread_mutex_timedlock函数：

(a) 若在outtime时间节点之前获取到锁，则停止阻塞，返回ret=0；

(b) 若时间节点之后还未获取锁，则停止阻塞，返回ret=ETIMEDOUT超时。

4. 自旋锁

自旋锁与互斥锁功能一样，唯一一点不同的就是互斥量阻塞后休眠让出cpu，而自旋锁阻塞后不会让出cpu，会一直忙等待，直到得到锁！

自旋锁在用户态使用的比较少，在内核使用的比较多！自旋锁的使用场景：锁的持有时间比较短，或者说小于2次上下文切换的时间。

自旋锁在用户态的函数接口和互斥量一样，把pthread_mutex_xxx()中mutex换成spin，如：pthread_spin_init()。

5. 读写锁(非常适合于读写线程的变量共享情况)

假如现在一个线程a只是想读一个共享变量i，因为不确定是否会有线程去写他，所以我们还是要对它进行加锁。

但是这时候又一个线程b试图读共享变量i ，于是发现被锁住，那么b不得不等到a释放了锁后才能获得锁并读取 i 的值，但是两个读取操作即使是几乎同时发生也并不会像写操作那样造成竞争，因为他们不修改变量的值。

所以我们期望如果是多个线程试图读取共享变量值的话,那么他们应该可以立刻获取而不需要等待前一个线程释放因为读而加的锁。

读写锁可以很好的解决上面的问题。他提供了比互斥量跟好的并行性。因为以读模式加锁后当又有多个线程仅仅是试图再以读模式加锁时，并不会造成这些线程阻塞在等待锁的释放上。

相关读写锁的API具体如下：

int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr); // 初始化读写锁
int pthread_rwlockattr_destory(pthread_rwlockattr_t *attr); // 销毁回收读写锁
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); // 阻塞方式获取读锁
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); // 阻塞方式获取写锁
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); // 非阻塞方式获取读锁
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); // 非阻塞方式获取写锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); // 释放读写锁

具体使用实例代码如下：

#include <stdio.h>
#include <errno.h> // Error code head file(EBUSY)
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h> // Pthread head file

pthread_rwlock_t rw_lock = PTHREAD_RWLOCK_INITIALIZER;
int global = 0;

void *thread_read_func(void *arg);
void *thread_write_func(void *arg);

int main(void)
{
    pthread_t th1,th2;
    printf("Mutil_Thread_Sys Starting...\n"); // Show the Starting point.
    pthread_mutex_unlock(GMemory->g_mutex);
    pthread_create(&th2,NULL,thread_read_func,"Read-TH"); // Create the Thread2 & Start the thread func2.
    pthread_create(&th1,NULL,thread_write_func,"Write_TH"); // Create the Thread1 & Start the thread func1.

    while(1){ // Main Processing thread.
        ;
    }

    pthread_join(th2,NULL); // wait the Thread2 end.
    pthread_join(th1,NULL); // Wait the Thread1 end.

    printf("System Exit.\n"); // Show the Ending point.
    return 0;
}

void *thread_read_func(void *arg)
{  
    bool ret;
    char *pthr_name = (char *)arg;
    while(1){
        ret = pthread_rwlock_rdlock(&rw_lock);
        printf("The %s Read value:%d\n",pthr_name,global);
        usleep(5000);
        pthread_rwlock_unlock(&rw_lock);
    }
}

void *thread_write_func(void *arg)
{
    bool ret;
    char *pthr_name = (char *)arg;
    while(1){
        ret = pthread_rwlock_wrlock(&rw_lock);
        global++;
        usleep(5000);
        printf("The %s Write thread value:%d\n",pthr_name,global);
        pthread_rwlock_unlock(&rw_lock);
    }
}

运行结果如下：

 

三、线程间通讯方式

1. 全局变量通信

由于线程使用的栈空间和堆空间都是进程的，而多线程都属于进程，故而全局变量能够被多个线程同时访问(为了防止使用混乱，采用锁机制来对全局变量进行访问即可)；

typedef struct Global_Memory{ // #define new struct type var with mutex lock and data also using-time.
    pthread_mutex_t *g_mutex; // The mutex lock variable define
    unsigned int Memory[10]; // The truly Data you will deal with.
}GMem;

设计如上所示的结构体变量，并在全局定义，此时即可将Memory空间和g_mutex锁变量进行了绑定，只有获取锁的状态下才可以修改Memory当中的内容，从而能够有序的完成线程间同信。

具体实现代码如下：

#include <stdio.h>
#include <errno.h> // Error code head file(EBUSY)
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h> // Pthread head file

typedef struct Global_Memory{ // #define new struct type var with mutex lock and data also using-time.
    pthread_mutex_t *g_mutex; // The mutex lock variable define
    unsigned int Memory[10]; // The truly Data you will deal with.
    int using_time; // Using time setup.
}GMem;

GMem *GMemory = NULL; // #define the mutex-lock & Memory variable

void *thread_func1(void *arg); // #define the thread functions
void *thread_func2(void *arg);

int main(void)
{
    pthread_t th1,th2;
    GMemory = (GMem *)malloc(sizeof(GMem)); // Allocal the storage spcae for Memory Data and time_using.
    GMemory->g_mutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)); // Allocal the memory space for the mutex variable.

    printf("Mutil_Thread_Sys Starting...\n"); // Show the Starting point.
    pthread_mutex_init(GMemory->g_mutex,NULL); // Initialize the mutex.
    pthread_create(&th1,NULL,thread_func1,NULL); // Create the Thread1 & Start the thread func1.
    pthread_create(&th2,NULL,thread_func2,NULL); // Create the Thread2 & Start the thread func2.

    while(1){ // Main Processing thread.
        printf("This is the Main Processing...\n");
        sleep(1); // Delay time cost 1second.
    }

    pthread_join(th1,NULL); // Wait the Thread1 end.
    pthread_join(th2,NULL); // wait the Thread2 end.
    printf("System Exit.\n"); // Show the Ending point.
    return 0;
}

void *thread_func1(void *arg) // Func1 Point address Define.(void *)
{
    time_t t_s; // Define a time_t var for storage the thread ending timestamp.
    while(1){
        pthread_mutex_lock(GMemory->g_mutex); // try to get the mutex lock var, if success, the thread is going to run and deal with the Memory Data.
        printf("********************************************************************************Func1 Locked.\n"); // Print the mutex lock var's state.
        t_s = time(NULL) + 1; // setup the ending time of the thread.
        while(time(NULL) <= t_s){ // Control the ending time.
            GMemory->Memory[1]++; // Deal with the Memory Data.
            printf("This is thread_func1 Running:Memory[1]=%d  Memory[2]=%d\n",GMemory->Memory[1],GMemory->Memory[2]); // show the result the thread just did.
            usleep(1000); // us delay for testing the thread time control.
        }
        pthread_mutex_unlock(GMemory->g_mutex); // Unlock the mutex variable so that other thread could use the mutex lock variable.
        printf("********************************************************************************Func1 Unlocked.\n"); // Print the mutex lock var's state.
    }
}

void *thread_func2(void *arg)
{
    time_t t_s;
    while(1){
        // int ret = pthread_mutex_trylock(GMemory->g_mutex); // Use the Trylock function will make the func2 to be sleeped, Use lock to make sure the Func2 thread could be called. 
        // if(EBUSY == ret) continue;
        pthread_mutex_lock(GMemory->g_mutex);
        printf("********************************************************************************Func2 Locked.\n");
        t_s = time(NULL) + 1;
        while(time(NULL) <= t_s){
            GMemory->Memory[2]++;
            printf("This is thread_func2 Running:Memory[1]=%d  Memory[2]=%d\n",GMemory->Memory[1],GMemory->Memory[2]);
            usleep(1000);
        }
        pthread_mutex_unlock(GMemory->g_mutex);
        printf("********************************************************************************Func2 Unlocked.\n");
    }
}

2. 消息队列

     参考这里

3. 信号量唤醒

信号量作为基本的通信方式，在线程阻塞睡眠唤醒的过程当中，充当着非常重要的角色，如下所示为条件信号量的定义及使用：

pthread_cond_t *g_cond; // condition semaphore define
ret = pthread_cond_timedwait(g_cond,GMemory->g_mutex,&outtime); // Waitting for the trigger signal and active the threads in queue while the outtime.
ret = pthread_cond_wait(g_cond, GMemory->g_mutex); // unlock the g_mutex lock and wait for the condition trigger.
pthread_cond_broadcast(g_cond); // broadcast trigger all threads in the queue.
pthread_cond_signal(g_cond); // Only wake up the first thread in the front of wait-queue.

2，3行在线程中用来等待其他线程使用4，5行来进行cond信号量唤醒。

四、生产者消费者模型

1. 如下图所示为基本的线程状态切换流程：

 2. 基本相关多线程框架案例

(a) 延迟阻塞多线程框架：

框架介绍：多个线程在不同时间节点启动，获取同一公共资源，每个线程都能设置自身独立的阻塞等待的时间，若获取资源等待超时，则放弃等待。

bool th_queue_run(long wt_ms, long choke_ms,int th)
{
    int ret;
    long time_ns=0;
    struct timespec outtime;
    clock_gettime(CLOCK_REALTIME, &outtime); // Get the current time.
    outtime.tv_sec += wt_ms / 1000;
    time_ns = outtime.tv_nsec + (wt_ms % 1000) * 1000000;
    if(time_ns >= 1000000000){
        outtime.tv_sec++;
        outtime.tv_nsec = time_ns - 1000000000;
    }else{
        outtime.tv_nsec = time_ns;
    }
    ret = pthread_mutex_timedlock(GMemory->g_mutex ,&outtime);
    if(ret != 0){
        if(ret == ETIMEDOUT){
            printf("%d Timeout | Compete, Running Failed!\n",th);
            return false;
        }
    }
    printf("%d Running successfully.\n",th);
    GMemory->Memory[th]++;
    printf("Memory[3] Memory[4] **** %d %d\n",GMemory->Memory[3],GMemory->Memory[4]);
    sleep(choke_ms);
    pthread_mutex_unlock(GMemory->g_mutex);
    return true;
}

(b) 未完待续

五、关于线程调度

1. Linux下的sleep()和sched_yield()

sched_yield()的man手册描述如下：

DESCRIPTION

    sched_yield()  causes  the  calling  thread to relinquish the CPU.  The  thread is moved to the end of the queue for its static priority  and  a  new thread gets to run.

RETURN VALUE

    On  success,  sched_yield()  returns  0.  On error, -1 is returned, and errno is set appropriately.

ERRORS

    In the Linux implementation, sched_yield() always succeeds.

翻译一下，sched_yield()会让出当前线程的CPU占有权，然后把线程放到静态优先队列的尾端，然后一个新的线程会占用CPU，那这个和sleep()有啥区别呢？

• sched_yield()这个函数可以使用另一个级别等于或高于当前线程的线程先运行。如果没有符合条件的线程，那么这个函数将会立刻返回然后继续执行当前线程的程序。
• 而sleep则是等待一定时间后等待CPU的调度，然后去获得CPU资源（这也是usleep()为什么不准的原因）。

那么什么时候使用sched_yield()呢？

Strategic calls to sched_yield() can improve performance by giving other threads or processes a chance to run when (heavily) contended resources (e.g., mutexes) have been released by the caller.

 翻译一下，有策略的调用sched_yield()能在资源竞争情况很严重时，通过给其他的线程或进程运行机会的方式来提升程序的性能。也就是说，调用sched_yield()能让你的当前线程让出资源，通过一定的策略调用sched_yield()满足你的业务要求可以保证各个线程或进程都有机会运行。

2. Linux下杀死指定的线程

I. 线程终止的 4 种方式：

• 线程的执行函数返回了，这和 main() 函数结束类似。
• 线程调用了 pthread_exit() 函数，这和调用 exit() 返回类似。
• 线程被另一个线程通过 pthread_cancel() 函数取消，这和通过kill() 发送 SIGKILL 信号类似。
• 进程终止了，则进程中的所有线程也会终止。

II. 取消某个线程的常规步骤：

a) 被取消的线程操作：

• 允许取消，pthread_setcancelstate()，参数可选值：
  • PTHREAD_CANCEL_ENABLE，这是默认值;
  • PTHREAD_CANCEL_DISABLE;
• 设置取消类型，pthread_setcanceltype()，参数可选值：
• PTHREAD_CANCEL_ASYNCHRONOUS，异步方式，当发出取消请求后，线程可能会在任何点被杀死。
  
• PTHREAD_CANCEL_DEFERRED，延迟方式，线程只会在特定的取消点（cancellation points，调用某个函数前）被杀死，这是默认值。

b) 发起取消的线程：

• 发送取消要求，pthread_cancel()，发出取消请求后，pthread_cancel() 当即返回，不会等待目标线程的退出。
• 等待取消完成，pthread_join()。

c) 哪些函数是取消点？

III. 实验代码：

1. 不使用特定的取消点，任意可能位置销毁线程：

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>
#include <sys/time.h>

void *thread_func(void *arg);

int main(void)
{
    pthread_t th1;
    void *pth_state; // 用来记录线程回收的状态情况

    pthread_create(&th1, NULL, thread_func, NULL); // 创建线程
    sleep(5);
    pthread_cancel(th1); // 取消销毁线程, 对于自动退出的线程, 无需取消线程
    pthread_join(th1, &pth_state); // 阻塞等待回收线程资源
    if(PTHREAD_CANCELED == pth_state){
      printf("thread1 was terminate by cancel\n");
    }else{
      printf("thread1 was not terminate by cancel\n");
    }
    exit(EXIT_SUCCESS);
    return 0;
}

void *thread_func(void *arg)
{
  int i = 2;
  printf("Welcome Thread test...\n");
  pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);   // 设置取消功能使能, 否则线程将无法被注销, 默认为 PTHREAD_CANCEL_ENABLE
  pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);  // 设置异步杀死功能, 线程可能在任何位置处被杀死:PTHREAD_CANCEL_ASYNCHRONOUS 特定的取消点:PTHREAD_CANCEL_DEFERRED
  for(;i>0;){
    printf("Thread is running...\n");
    sleep(1); // sleep为默认的取消点位置, 因此此线程函数的取消位置一般为sleep函数调用之前 pthread_testcancel(); //主动设置取消点, 主动设置的取消点优先级低于系统默认函数的优先级
  }
  return NULL; // pthread_exit((void*)0); // 直接使用函数终止结束当前线程
}

IV. 应用场景注意事项[参考这里]：

基本需求场景：

对于一般的线程而言，不牵扯mutex锁的情况下，直接取消是不存在问题的，然而对于某些使用到线程锁mutex变量的线程，则不能随意节点取消(否则会导致资源被永久占用锁定!)，具体分析如下：   

最经常出现的情形是资源独占锁的使用：线程为了访问临界资源而为其加上锁，但在访问过程中被外界取消，如果线程处于响应取消状态，且采用异步方式响应，或者在打开独占锁以前的运行路径上存在取消点，则该临界资源将永远处于锁定状态得不到释放。

外界取消操作是不可预见的，因此的确需要一个机制来简化用于资源释放的编程，例如下述代码，如取消线程前，不处理释放锁，则会出现资源死锁问题：

pthread_mutex_t mut; // 定义mutex锁变量
pthread_cleanup_push(pthread_mutex_unlock, (void *)&mut); // 线程取消退出前的处理程序记录在栈中，函数执行顺序与注册顺序相反
pthread_mutex_lock(&mut); // 使用资源前对其加锁
/* do some work */   
pthread_mutex_unlock(&mut); // 使用完资源释放锁
pthread_cleanup_pop(0); // 线程取消退出前执行栈中函数

函数接口介绍：

线程可以安排他退出时需要调用的函数，这与进程可以用atexit函数安排进程退出时需要调用的函数是类似的。这样的函数称为线程清理处理程序，线程可以建立多个清理处理程序。处理程序记录在栈中，也就是说他们的执行顺序与他们注册的顺序相反，接口如下：

• 头文件：#include <pthread.h>
• 入栈注册函数原型：
  • void pthread_cleanup_push(void (*rtn)(void *), void *arg);
  • void(*rtn)(void *)：线程清理函数;
  • void *arg：清理函数参数;
• 出栈注册函数原型：
  • void pthread_clean_pop(int execute);
  • int execute：清理函数出栈执行编号;

注意事项：

    必须要注意的是，如果线程处PTHREAD_CANCEL_ASYNCHRONOUS状态，上述代码段就有可能出错，因为CANCEL事件有可能在pthread_cleanup_push()和pthread_mutex_lock()之间发生，或者在pthread_mutex_unlock()和pthread_cleanup_pop()之间发生，从而导致清理函数unlock一个并没有加锁的 mutex变量，造成错误。因此，在使用清理函数的时候，都应该暂时设置成PTHREAD_CANCEL_DEFERRED模式。为此，POSIX的Linux实现中还提供了一对不保证可移植的pthread_cleanup_push_defer_np()/pthread_cleanup_pop_defer_np()扩展函数，功能与以下代码段相当：

{
    pthread_mutex_t mut; // 定义mutex锁变量
    int oldtype; // 用于暂存当前的pthread_setcanceltype状态

    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &mut, oldtype); //设置为同步取消，这样保证push和其他操作不能被打断   
    pthread_cleanup_push(routine, arg); // 入栈线程取消前函数routine+参数arg
    pthread_cleanup_pop(execute); // 出栈执行函数
    pthread_setcanceltype(oldtype, NULL); // 恢复之前的pthread_setcanceltype状态
}

测试代码：

#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
void clean_fun1(void * arg)
{
    printf("this is clean fun1\n");
}
void clean_fun2(void * arg)
{
    printf("this is clean fun2\n");
}
void * thread_fun(void * arg)
{
    pthread_cleanup_push(clean_fun1,NULL);
    pthread_cleanup_push(clean_fun2,NULL);
    sleep(100);
    //这里要注意,如果将sleep(100);换成while(1);的话,程序会一直暂停.push和pop要成对出现.
    //因为while(1);运行的太快,线程不接受cancel信号
    //while(1);
    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);
    return NULL;
}
int main()
{
    pthread_t tid1;
    int err;
    err=pthread_create(&tid1,NULL,thread_fun,NULL);
    if(err!=0)
    {
        perror("pthread_create");
        exit(0);
    }
    sleep(3);
    //printf("test\n");
    err=pthread_cancel(tid1);
    if(err!=0)
    {
        perror("cancel error:");
        exit(0);
    }
    err=pthread_join(tid1,NULL);
    if(err!=0)
    {
        perror("pthread_join  error:");
        exit(0);
    }
     
    return 0;
}

https://www.cnblogs.com/love-DanDan/p/8724241.html

https://blog.csdn.net/wuweidonggmail/article/details/111056048

https://blog.csdn.net/qixiang2013/article/details/126126112  多线程私有数据pthread_key_create

https://pubs.opengroup.org/onlinepubs/7908799/xsh/pthread_condattr_init.html   int pthread_condattr_init(pthread_condattr_t *attr);

https://blog.csdn.net/ericbar/article/details/79879850   Linux下pthread_once()函数

Reference：

树莓派多线程点灯：https://github.com/embedded-learning-group/Linux_Learning/tree/master/20190818_Lesson7

相关thread API函数接口介绍：https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_mutex_timedlock.html

POSIX线程详解(第三部分)：https://www.ibm.com/developerworks/cn/linux/thread/posix_thread3/index.html

线程同步及消息队列：https://www.cnblogs.com/noticeable/p/8549788.html

消息队列通信详解：https://blog.csdn.net/anonymalias/article/details/9799645

杀死某一个线程：https://blog.csdn.net/wuweidonggmail/article/details/111056048