Linux 线程(pthread)

pthread库不是标准的Linux 的库所以编译的时候要加"-".
涉及多线程开发的最基本概念主要包含三点：线程、互斥锁、条件。
其中，线程又分为线程的创建、退出、等待三种。
互斥锁包括4种操作：创建、销毁、加锁和解锁。
条件操作有5种：创建、销毁、触发、广播和等待。
其他的一些线程扩展概念，如信号灯等，都是通过上面的三个基本元素的基本操作封装出来。

1、线程创建

#include <pthread.h>

int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict attr,void *(*start_rtn)(void *),void *restrict arg);
//返回：若成功返回0，否则返回错误编号。

pthread_t:在头文件手册说中声明unsigned long类型指针
const pthread_attr_t ＊restrict attr :线程的属性，是一个长整型的指针。
void *(*start_rtn)(void *)：在这个线程里面干活的函数
*void restrict arg　：给这个线程传参的参数是传给上面这个函数的参数

新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg。如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放到一个
结构体中，然后把这个结构地址作为arg参数传入； 因为arg是一个无类型的指针，它可以传int 、char等等，只要是一个指针。

2、线程的退出

单个线程可以通过以下三种方式退出，在不终止整个进程的情况下停止它的控制流：
1）线程只是从启动例程中返回，返回值是线程的退出码。
2）线程可以被同一进程中的其他线程取消。
3）线程调用pthread_exit:
#include <pthread.h>
int pthread_exit(void *rval_ptr);
rval_ptr是一个无类型的指针，与传给启动例程的单个参数类似。进程中的其他线程可通过调用pthread_join函数访问到这个指针。

3.线程的等待

static修饰全局变量。
#include<pthread.h>
int pthread_join(pthread_t thread,void **rval_ptr);
//返回：若成功返回0，否则返回错误编号
调用这个函数的线程将一直阻塞，直到指定的线程调用pthread_exit、从启动例程中返回或者被取消
如果例程只是从它的启动例程返回i,rval_ptr将包含返回码。如果线程被取消，由rval_ptr指定的内存
单元就置为PTHREAD_CANCELED。 pthread_join 可以读取pthread_exit的返回值。然后进行输出。
可以通过调用pthread_jion 自动把线程置于分离状态，这样资源就可以恢复。如果线程已经处于分离状态，pthread_jion
调用就会失败，返回EINVAL
如果对线程的返回值不感兴趣，可以把rval_ptr置为NULL。在这种情况下，调用pthread_jion函数将等待指定的线程终止，
饭并不会获得线程的终止状态。

4.线程的脱离

一个线程或者是可汇合（joinable，默认值），或者是脱离的（detached）。当一个可以汇合的线程终止时，它的线程ID和退出状态将

留存到另一个线程对它调用pthread_join。脱离的线程却像守护进程，当它们终止时，所有的相关资源都将被释放，我们不能等待它们终止。如果一个线程需要知道另一个
线程什么时候终止，那就最好保持第二个线程的可汇合状态。
pthread_detach函数把指定的线程变为脱离状态。
int pthread_detach (pthread_t thread);
//返回：若成功返回0，否则返回错误编号
本函数通常想让自己脱离的线程使用，就如以下语句：
pthread_detach(pthread_self());

5.线程ID获取及比较

pthread_t pthread_self(void);
//返回：调用线程ID
对于线程ID比较，为了可移植操作，我们不能简单的把线程ID当做整数处理，因为不同系统对线程ID的定义可能不一样。
我们应该要用下边的函数：
int pthread_equal(pthread_t *tidl,pthread_t *tid2);//判断两个线程是不是同一个线程。
//返回：若相等则返回非0值，否则返回0

互斥量

从本质上讲是一把锁，在访问共享资源前对互斥量进行加锁，在访问完后释放互斥量上的锁。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程都将
被阻塞直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有等待的线程都来抢夺互斥锁，
第一个变为可运行状态的线程可以对互斥量加锁，然后其他线程就又阻塞，只能等待它重新变成可用，在这这种方式下，每次只有一个线程可以向前运行。
设计时需要规定所有线程必须遵守相同的数据访问规则，只有这样互斥机制才能正常进行。
操作系统并不会做数据的串行化。如果允许其中某个线程在没有得到锁的情况下访问共享资源，
那么在其他线程在使用共享资源前都获得锁，也还是会出现数据不一致的问题。
互斥量用pthread_mutex_t数据类型表示。在使用互斥变量前必须对它进行初始化，可以把它置为常量
PTHREAD_MUTEX_INITIALIZER(只对静态分配的互斥量)，也可以通过调用pthread_mutex_init函数进行初始化。如果动态地址
分配互斥量（例如通过调用malloc函数），那么在释放内存前需要调用pthread_mutex_destroy。
1.创建及销毁互斥锁
#include<pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
//返回：若成功返回键0，否则返回错误编码
要用默认属性初始化互斥量，只需要把attr设置为NULL。

2.加锁和解锁
#include <pthread.h>
int pthread_mutex_lock(pthread_nutex_t *mutex);
int pthread_mutex_trylock(pthread_nutex_t *mutex);
int pthread_mutex_unlock(pthread_nutex_t *mutex);
如果线程不希望被阻塞，它可以使用pthread_mutex_trylock尝试对
互斥量进行加锁。如果调用pthead_mutex_trylock时互斥量处于未锁住状态，那么pthread_trylock将锁住互斥量，不会出现
阻塞并返回0，否则pthread_mutex_trylock就会失败，不能锁住互斥量，而返回EBUSY。

什么情况会造成死锁？
有两把或者多把锁的时候
其中两个或着多个线程获得一把锁没有释放又想获得第二把锁，导致所想要获得的锁都有线程占有
无法获得锁的线程就会阻塞。

与条件变量相关的API

1.创建及销毁条件变量

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(phtread_cond_t *cond);
//返回：若成功返回0，否则返回错误编号
除非要创建一个非默认属性的条件变量，否则pthread_cond_init函数中的attr参数可以设置为NULL

2.等待

int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);
int pthread_cond_timewait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex,cond struct timespec *restrict timeout);
//返回：若成功返回0，否则返回错误编号
pthread_cond_wait等待条件变为真。如果在给定的时间内条件不满足，那么会生成一个代表一个出错码的返回变量。传递给pthread_cond_wait的互斥量对条件进行保护，调用者把锁住的互斥量传给函数。函数把调用的线程放到等待条件的线程列表上，然后互斥锁解锁，这两个操作都是原子操作。
所谓原子操作，就是该操作绝不会在执行完毕前被任何其他任务或事件打断，也就说，它的最小的执行单位，不可能有比它更小的执行单位，因此这里的原子实际是使用了物理学里的物质微粒的概念。
原子操作需要硬件的支持，因此是架构相关的，其API和原子类型的定义都定义在内核源码树的include/asm/atomic.h文件中，它们都使用汇编语言实现，因为C语言并不能实现这样的操作。
如果在pthread_cond_wait()后面在接pthread_mutex_lock()将会导致所有的线程都阻塞。原因如下面所说需要调用pthread_mutex_init()或者pthread_mutex_unlock()函数
这样关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道，这样线程就不会错过条件的任何变化。pthread_cond_wait返回时，互斥量再次被锁住。

pthread_mutex_lock(&mtx);           //这个mutex主要是用来保证pthread_cond_wait的并发性
while (head == NULL)   {               //这个while要特别说明一下，单个pthread_cond_wait功能很完善，为何这里要有一个while (head == NULL)呢？因为pthread_cond_wait里的线程可能会被意外唤醒，如果这个时候head != NULL，则不是我们想要的情况。这个时候，应该让线程继续进入pthread_cond_wait

为什么pthread_cond_wait(),为什么要放在pthread_mutex_lock()和pthread_mutex_unlock()之间呢
因为他要根据共享内存变量的状态决定是否要等待，而为了不永远等下去，所以必须要在lock和unlock之间。
共享变量的状态改变必须要遵守lock和unlock的规则
即：pthread_cond_signal即可放在lock和unlock之间也可以放在lock和unlock之后

pthread_cond_timewait函数的工作方式与pthread_cond_wait函数类似，只是多了一个timeout。timeout指定了等待时间，它是通过timespec结构指定的。

#include<sys/time.h>
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
printf(“clock_gettime : tv_sec=%ld, tv_nsec=%ld\n”, ts.tv_sec, ts.tv_nsec);

3、触发
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
//返回：若成功返回0，否则返回错误编号
这两个函数可以用于通知线程条件已经满足。pthread_cond_signal函数将唤醒等待该条件的某个线程，而pthread_cond_broadcast函数将唤醒等待该条件的所有进程。
注意一定要在改变条件状态后再给线程发信号。

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER 这是静态初始化,是一个宏定义,可以放在mian函数前面
pthread_mutex_t cond = PTHREAD_COND_INITIALIZER
pthread_mutex_t mutex;
pthread_mutex_init(&mutex,NULL); //这是动态初始化

通过代码发现有趣现象

先放结果:
结果显示:通过这个现象来看出来的运行顺序是
得