概念

什么是线程

在一个程序里的一个执行路线就叫做线程（thread。更准确的定义是线程是“一个进程内部的控制序列”
一切进程至少都有一个执行线程线程在进程内部运行本质是在进程地址空间内运行
在Linux系统中在CPU眼中看到的PCB都要比传统的进程更加轻量化。透过进程虚拟地址空间可以看到进程的大部分资源将进程资源合理分配给每个执行流就形成了线程执行流。

---

线程的优点

• 创建一个新线程的代价要比创建一个新进程小得多
• 与进程之间的切换相比线程之间的切换需要操作系统做的工作要少很多
• 线程占用的资源要比进程少很多
• 能充分利用多处理器的可并行数量
• 在等待慢速I/O操作结束的同时程序可执行其他的计算任务
• 计算密集型应用为了能在多处理器系统上运行将计算分解到多个线程中实现
• I/O密集型应用为了提高性能将I/O操作重叠。线程可以同时等待不同的I/O操作。

---

线程的缺点

性能损失
        一个很少被外部事件阻塞的计算密集型线程往往无法与共它线程共享同一个处理器。如果计算密集型线程的数量比可用的处理器多那么可能会有较大的性能损失这里的性能损失指的是增加了额外的同步和调度开销而可用的资源不变。
健壮性降低
        编写多线程需要更全面更深入的考虑在一个多线程程序里因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的换句话说线程之间是缺乏保护的。
缺乏访问控制
        进程是访问控制的基本粒度在一个线程中调用某些OS函数会对整个进程造成影响。
编程难度提高
        编写与调试一个多线程程序比单线程程序困难得多        

---

 线程异常

• 单个线程如果出现除零野指针问题导致线程崩溃进程也会随着崩溃
• 线程是进程的执行分支线程出异常就类似进程出异常进而触发信号机制终止进程进程终止该进程内的所有线程也就随即退出

---

线程用途

• 合理的使用多线程能提高CPU密集型程序的执行效率
• 合理的使用多线程能提高IO密集型程序的用户体验（如生活中我们一边写代码一边下载开发工具就是多线程运行的一种表现

---

进程和线程

进程是资源分配的基本单位
线程是调度的基本单位
线程共享进程数据但也拥有自己的一部分数据:

• 线程ID
• 一组寄存器
• 栈
• errno
• 信号屏蔽字
• 调度优先级

进程的多个线程共享 同一地址空间,因此如果定义一个函数,在各线程中都可以调用,如果定义一个全局变量,在各线程中都可以访问到,除此之外,各线程还共享以下进程资源和环境:

• 文件描述符表
• 每种信号的处理方式(SIG_ IGN、SIG_ DFL或者自定义的信号处理函数)
• 当前工作目录
• 用户id和组id

 

---

接口

        创建线程

        功能创建一个新的线程
原型
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg);
参数
thread:返回线程ID
attr:设置线程的属性attr为NULL表示使用默认属性
start_routine:是个函数地址线程启动后要执行的函数
arg:传给线程启动函数的参数
返回值成功返回0；失败返回错误码
 

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>
void *rout(void *arg) 
{
    int i;
    for( ; ; ) 
    {
        printf("I'am thread 1\n");
        sleep(1);
    }
} 
int main( void )
{
    pthread_t tid;
    int ret;
    if ( (ret=pthread_create(&tid, NULL, rout, NULL)) != 0 ) 
    {
    fprintf(stderr, "pthread_create : %s\n", strerror(ret));
    exit(EXIT_FAILURE);
    }
    int i;
    for(; ; )
    {
    printf("I'am main thread\n");
    sleep(1);
    }
}

---

线程ID及进程地址空间布局

pthread_ create函数会产生一个线程ID存放在第一个参数指向的地址中。该线程ID和前面说的线程ID不是一回事。
前面讲的线程ID属于进程调度的范畴。因为线程是轻量级进程是操作系统调度器的最小单位所以需要一个数值来唯一表示该线程。
pthread_ create函数第一个参数指向一个虚拟内存单元该内存单元的地址即为新创建线程的线程ID属于NPTL线程库的范畴。线程库的后续操作就是根据该线程ID来操作线程的。
线程库NPTL提供了pthread_ self函数可以获得线程自身的ID

pthread_t 到底是什么类型呢？取决于实现。对于Linux目前实现的NPTL实现而言pthread_t类型的线程ID本质就是一个进程地址空间上的一个地址。

---

线程终止

如果需要只终止某个线程而不终止整个进程,可以有三种方法:
1. 从线程函数return。这种方法对主线程不适用,从main函数return相当于调用exit。
2. 线程可以调用pthread_ exit终止自己。
3. 一个线程可以调用pthread_ cancel终止同一进程中的另一个线程。

pthread_exit函数

功能线程终止
原型
void pthread_exit(void *value_ptr);
参数
value_ptr:value_ptr不要指向一个局部变量。
返回值无返回值跟进程一样线程结束的时候无法返回到它的调用者（自身

需要注意,pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的,不能在线程函数的栈上分配,因为当其它线程得到这个返回指针时线程函数已经退出了
 pthread_cancel函数

功能取消一个执行中的线程
原型
int pthread_cancel(pthread_t thread);
参数
thread:线程ID
返回值成功返回0；失败返回错误码

pthread_join

功能等待线程结束
原型
int pthread_join(pthread_t thread, void **value_ptr);
参数
thread:线程ID
value_ptr:它指向一个指针后者指向线程的返回值
返回值成功返回0；失败返回错误码

调用该函数的线程将挂起等待,直到id为thread的线程终止。thread线程以不同的方法终止,通过pthread_join得到的
终止状态是不同的总结如下:

1. 如果thread线程通过return返回,value_ ptr所指向的单元里存放的是thread线程函数的返回值。
2. 如果thread线程被别的线程调用pthread_ cancel异常终掉,value_ ptr所指向的单元里存放的是常数PTHREAD_ CANCELED。
3. 如果thread线程是自己调用pthread_exit终止的,value_ptr所指向的单元存放的是传给pthread_exit的参数。
4. 如果对thread线程的终止状态不感兴趣,可以传NULL给value_ ptr参数。

---

分离线程 

默认情况下新创建的线程是joinable的线程退出后需要对其进行pthread_join操作否则无法释放资源从而造成系统泄漏。
如果不关心线程的返回值join是一种负担这个时候我们可以告诉系统当线程退出时自动释放线程资源

---

Linux线程互斥

进程线程间的互斥相关背景概念

临界资源多线程执行流共享的资源就叫做临界资源
临界区每个线程内部访问临界资源的代码就叫做临界区
互斥任何时刻互斥保证有且只有一个执行流进入临界区访问临界资源通常对临界资源起保护作用
原子性（后面讨论如何实现不会被任何调度机制打断的操作该操作只有两态要么完成要么未完成

互斥量mutex

大部分情况线程使用的数据都是局部变量变量的地址空间在线程栈空间内这种情况变量归属单个线程其他线程无法获得这种变量。
但有时候很多变量都需要在线程间共享这样的变量称为共享变量可以通过数据的共享完成线程之间的交互。
多个线程并发的操作共享变量会带来一些问题

---

互斥量的接口

初始化互斥量

初始化互斥量有两种方法
方法1静态分配:

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

方法2动态分配:

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict
attr);
参数
mutex要初始化的互斥量
attrNULL

销毁互斥量

销毁互斥量需要注意
使用 PTHREAD_ MUTEX_ INITIALIZER 初始化的互斥量不需要销毁
不要销毁一个已经加锁的互斥量
已经销毁的互斥量要确保后面不会有线程再尝试加锁

int pthread_mutex_destroy(pthread_mutex_t *mutex)

互斥量加锁和解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值:成功返回0,失败返回错误号

调用 pthread_ lock 时可能会遇到以下情况:

互斥量处于未锁状态该函数会将互斥量锁定同时返回成功
发起函数调用时其他线程已经锁定互斥量或者存在其他线程同时申请互斥量但没有竞争到互斥量那么pthread_ lock调用会陷入阻塞(执行流被挂起)等待互斥量解锁。

调用 pthread_ lock 时可能会遇到以下情况:

• 互斥量处于未锁状态该函数会将互斥量锁定同时返回成功
• 发起函数调用时其他线程已经锁定互斥量或者存在其他线程同时申请互斥量但没有竞争到互斥量那么pthread_ lock调用会陷入阻塞(执行流被挂起)等待互斥量解锁

 售票系统

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>
int ticket = 100;
pthread_mutex_t mutex;
void *route(void *arg)
{
    char *id = (char*)arg;
    while ( 1 ) 
    {
    pthread_mutex_lock(&mutex);
    if ( ticket > 0 ) 
    {
    usleep(1000);
    printf("%s sells ticket:%d\n", id, ticket);
    ticket--;
    pthread_mutex_unlock(&mutex);
    // sched_yield(); 放弃CPU
    } 
    else {
    pthread_mutex_unlock(&mutex);
    break;
    }
    }
} 
int main( void )
{
    pthread_t t1, t2, t3, t4;
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&t1, NULL, route, "thread 1");
    pthread_create(&t2, NULL, route, "thread 2");
    pthread_create(&t3, NULL, route, "thread 3");
    pthread_create(&t4, NULL, route, "thread 4");
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    pthread_mutex_destroy(&mutex);
}

互斥量实现原理探究

经过上面的例子大家已经意识到单纯的 i++ 或者 ++i 都不是原子的有可能会有数据一致性问题

为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的 总线周期也有先后,一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。 现在我们把lock和unlock的伪代码改一下

 可重入VS线程安全

概念
线程安全多个线程并发同一段代码时不会出现不同的结果。常见对全局变量或者静态变量进行操作并且没有锁保护的情况下会出现该问题。
重入同一个函数被不同的执行流调用当前一个流程还没有执行完就有其他的执行流再次进入我们称之为重入。一个函数在重入的情况下运行结果不会出现任何不同或者任何问题则该函数被称为可重入函数否则是不可重入函数

常见的线程不安全的情况

• 不保护共享变量的函数
• 函数状态随着被调用状态发生变化的函数
• 返回指向静态变量指针的函数
• 调用线程不安全函数的函数

常见的线程安全的情况

• 每个线程对全局变量或者静态变量只有读取的权限而没有写入的权限一般来说这些线程是安全的
• 类或者接口对于线程来说都是原子操作
• 多个线程之间的切换不会导致该接口的执行结果存在二义性

常见不可重入的情况

• 调用了malloc/free函数因为malloc函数是用全局链表来管理堆的
• 调用了标准I/O库函数标准I/O库的很多实现都以不可重入的方式使用全局数据结构
• 可重入函数体内使用了静态的数据结构

常见可重入的情况

• 不使用全局变量或静态变量
• 不使用用malloc或者new开辟出的空间
• 不调用不可重入函数
• 不返回静态或全局数据所有数据都有函数的调用者提供
• 使用本地数据或者通过制作全局数据的本地拷贝来保护全局数据

可重入与线程安全联系

• 函数是可重入的那就是线程安全的
• 函数是不可重入的那就不能由多个线程使用有可能引发线程安全问题
• 如果一个函数中有全局变量那么这个函数既不是线程安全也不是可重入的。

可重入与线程安全区别

• 可重入函数是线程安全函数的一种
• 线程安全不一定是可重入的而可重入函数则一定是线程安全的。
• 如果将对临界资源的访问加上锁则这个函数是线程安全的但如果这个重入函数若锁还未释放则会产生死锁因此是不可重入的。

---

常见锁概念        

死锁

死锁是指在一组进程中的各个进程均占有不会释放的资源但因互相申请被其他进程所站用不会释放的资源而处于的一种永久等待状态。

死锁四个必要条件

互斥条件一个资源每次只能被一个执行流使用
请求与保持条件一个执行流因请求资源而阻塞时对已获得的资源保持不放
不剥夺条件:一个执行流已获得的资源在末使用完之前不能强行剥夺
循环等待条件:若干执行流之间形成一种头尾相接的循环等待资源的关系

避免死锁

破坏死锁的四个必要条件
加锁顺序一致
避免锁未释放的场景
资源一次性分配

---

Linux线程同步

条件变量

当一个线程互斥地访问某个变量时它可能发现在其它线程改变状态之前它什么也做不了。
例如一个线程访问队列时发现队列为空它只能等待只到其它线程将一个节点添加到队列中。这种情况就需要用到条件变量。

同步概念与竞态条件

同步在保证数据安全的前提下让线程能够按照某种特定的顺序访问临界资源从而有效避免饥饿问题叫做同步
竞态条件因为时序问题而导致程序异常我们称之为竞态条件。在线程场景下这种问题也不难理解
条件变量函数 初始化

int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict
attr);
参数
cond要初始化的条件变量
attrNULL

销毁

int pthread_cond_destroy(pthread_cond_t *cond)

等待条件满足

int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);
参数
cond要在这个条件变量上等待
mutex互斥量后面详细解释

唤醒等待

int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);

为什么 pthread_cond_wait 需要互斥量?

条件等待是线程间同步的一种手段如果只有一个线程条件不满足一直等下去都不会满足所以必须要有一个线程通过某些操作改变共享变量使原先不满足的条件变得满足并且友好的通知等待在条件变量上的线程。
条件不会无缘无故的突然变得满足了必然会牵扯到共享数据的变化。所以一定要用互斥锁来保护。没有互斥锁就无法安全的获取和修改共享数据

 按照上面的说法我们设计出如下的代码先上锁发现条件不满足解锁然后等待在条件变量上不就行了如下代码:

// 错误的设计
pthread_mutex_lock(&mutex);
while (condition_is_false) {
pthread_mutex_unlock(&mutex);
//解锁之后等待之前条件可能已经满足信号已经发出但是该信号可能被错过
pthread_cond_wait(&cond);
pthread_mutex_lock(&mutex);
} 
pthread_mutex_unlock(&mutex);

• 由于解锁和等待不是原子操作。调用解锁之后 pthread_cond_wait 之前如果已经有其他线程获取到互斥量摒弃条件满足发送了信号那么 pthread_cond_wait 将错过这个信号可能会导致线程永远阻塞在这个 pthread_cond_wait 。所以解锁和等待必须是一个原子操作。
• int pthread_cond_wait(pthread_cond_ t *cond,pthread_mutex_ t * mutex); 进入该函数后会去看条件量等于0不？等于就把互斥量变成1直到cond_ wait返回把条件量改成1把互斥量恢复成原样
   

---

条件变量使用规范

等待条件代码

pthread_mutex_lock(&mutex);
while (条件为假
pthread_cond_wait(cond, mutex);
修改条件
pthread_mutex_unlock(&mutex);

给条件发送信号代码

pthread_mutex_lock(&mutex);
设置条件为真
pthread_cond_signal(cond);
pthread_mutex_unlock(&mutex);

---

POSIX信号量

POSIX信号量和SystemV信号量作用相同都是用于同步操作达到无冲突的访问共享资源目的。 但POSIX可以用于
线程间同步。
初始化信号量

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
参数
pshared:0表示线程间共享非零表示进程间共享
value信号量初始值

销毁信号量

int sem_destroy(sem_t *sem);

等待信号量

功能等待信号量会将信号量的值减1
int sem_wait(sem_t *sem); //P()

发布信号量

功能发布信号量表示资源使用完毕可以归还资源了。将信号量值加1。
int sem_post(sem_t *sem);//V()

---

基于环形队列的生产消费模型

环形队列采用数组模拟用模运算来模拟环状特性

环形结构起始状态和结束状态都是一样的不好判断为空或者为满所以可以通过加计数器或者标记位来
判断满或者空。另外也可以预留一个空的位置作为满的状态
 

但是我们现在有信号量这个计数器就很简单的进行多线程间的同步过程

#include <iostream>
#include <vector>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#define NUM 16
class RingQueue{
private:
    std::vector<int> q;
    int cap;
    sem_t data_sem;
    sem_t space_sem;
    int consume_step;
    int product_step;
public:
    RingQueue(int _cap = NUM):q(_cap),cap(_cap)
    {
    sem_init(&data_sem, 0, 0);
    sem_init(&space_sem, 0, cap);
    consume_step = 0;
    product_step = 0;
    } 
    void PutData(const int &data)
    {
    sem_wait(&space_sem); // P
    q[consume_step] = data;
    consume_step++;
    consume_step %= cap;
    sem_post(&data_sem); //V
    } 
    void GetData(int &data)
    {
    sem_wait(&data_sem);
    data = q[product_step];
    product_step++;
    product_step %= cap;
    sem_post(&space_sem);
    } 
    ~RingQueue()
    {
    sem_destroy(&data_sem);
    sem_destroy(&space_sem);
    }
    };
    void *consumer(void *arg)
    {
    RingQueue *rqp = (RingQueue*)arg;
    int data;
    for( ; ; )
    {
    rqp->GetData(data);
    std::cout << "Consume data done : " << data << std::endl;
    sleep(1);
    }
    } //more faster
    void *producter(void *arg)
    {
    RingQueue *rqp = (RingQueue*)arg;
    srand((unsigned long)time(NULL));
    for( ; ; ){
    int data = rand() % 1024;
    rqp->PutData(data);
    std::cout << "Prodoct data done: " << data << std::endl;
    // sleep(1);
    }
    } 
    int main()
    {
    RingQueue rq;
    pthread_t c,p;
    pthread_create(&c, NULL, consumer, (void*)&rq);
    pthread_create(&p, NULL, producter, (void*)&rq);
    pthread_join(c, NULL);
    pthread_join(p, NULL);
    }

---

线程池

 线程池:
* 一种线程使用模式。线程过多会带来调度开销进而影响缓存局部性和整体性能。而线程池维护着多个线程等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。
* 线程池的应用场景
* 1. 需要大量的线程来完成任务且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务使用线程池技术是非常合适的。因为单个任务小而任务数量巨大你可以想象一个热门网站的点击次数。 但对于长时间的任务比如一个Telnet连接请求线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。
* 2. 对性能要求苛刻的应用比如要求服务器迅速响应客户请求。
* 3. 接受突发性的大量请求但不至于使服务器因此产生大量线程的应用。突发性大量客户请求在没有线程池情况下将产生大量线程虽然理论上大部分操作系统线程数目最大值不是问题短时间内产生大量线程可能使内存到达极限出现错误.
* 线程池的种类
* 线程池示例
* 1. 创建固定数量线程池循环从任务队列中获取任务对象
* 2. 获取到任务对象后执行任务对象中的任务接口