四.用户级线程概念

1.线程异常了怎么办?—线程健壮性问题

线程异常了——>整个进程整体异常退出。 线程异常==进程异常
线程会影响其他线程的运行一新线程会影响主线程main thread 一健壮性/鲁棒性 较低，

2.理解 pthread_ t

是一个地址
1.线程是一个独立的执行流
2.线程一定会在自己的运行过程中，产生临时数据(调用函数，定义局部变量等)在新线程中修改全局变量后，新线程和主线程都能看到被修改后的结果
3.线程一定需要有自己的独立的栈结构

3.线程栈

 （1）代码区有三类代码

我们使用的线程库，用户级线程库，库的名字叫pthread

代码区有三类代码：

①你自己写的代码。

②库的接口代码。（例如动态库libpthread. so会写入内存，通过页表映射到进程的共享区，代码区的库接口代码通过跳转到共享区执行完库中的代码，然后再跳转回代码区继续执行）

③系统接口代码。（通过身份切换 用户—>内核 执行代码）

所有的代码执行，都是在进程的地址空间当中进行执行的

（2）解释 pthread_create 创建线程的返回值pthread_t

用户要用线程，但是OS没有线程的概念，libpthread. so线程库起承上启下的作用。

共享区内： 

线程的全部实现，并没有全部体现在OS内，而是OS提供执行流，具体的线程结构由库来进行管理。库可以创建多个线程->库也要管理线程->管理：先描述，在组织

struct thread_ info
{ 
        pthread_ t tidh .
        void *stack; //私有栈
        ……
}  

libpthread. so线程库映射进共享区中。创建线程时，线程库中也会创建一个 结构体struct thread_ info叫做 线程控制块， 线程控制块内部是描述线程的信息，内部有一个指针指向mm_struct用户空间的一块空间——线程栈。创建线程成功后，返回一个pthread_t类型的地址，pthread_t类型的地址保存着我们共享区中对应的用户级线程的线程控制块的起始地址!

 结论：主线程的独立栈结构，用的就是地址空间中的栈区；新线程用的栈结构，用的是库中提供的栈结构（这个线程栈是库维护的，空间还是用户提供的）

Linux中，线程库用户级线程库，和内核的LWP是1:1（LWP（类比PID）——light wait process：轻量级进程编号。LWP=PID的执行流是主线程，俗称进程）

（3）线程局部存储

线程库中的结构体struct thread_ info，内部是描述线程的信息，struct thread_ info中还有一个叫做线程局部存储的区域。作用：可以把全局变量私有化

正常情况全局变量是多个线程可以同时修改的：

加上__thread，把全局变量拷贝给每个进程各一份，使全局变量私有化，各自修改自己的全局变量

五.分离线程

1.概念

2.示例

（1）pthread_ detach(pthread_ self()); 新线程自我分离。

如果没有sleep(1)，就会出现新线程一直循环的情况。因为有可能主线程先执行 int n = pthread_ join(tid1, nullptr); 此时新线程还没有pthread_ detach分离，则主线程会一直阻塞在pthread_ join这里，不会返回。

当有sleep(1)时，新线程会先pthread_ detach自我分离。主线程后执行 int n = pthread_ join(tid1, nullptr); 此时新线程已经pthread_ detach分离，则主线程会直接pthread_ join返回错误码，证明了一个线程如果分离了就不能再join

（2）pthread_ detach(tid1);主线程分离新线程

建议主线程分离新线程，因为这样主线程一定是先分离了新线程，再pthread_ join。

3.线程分离可以理解为线程退出的第四种方式

（1）线程分离分为立即分离,延后分离，要保证线程还活着。线程分离意味着，我们不在关心这个线程的死活。线程分离可以理解为线程退出的第四种方式——延后退出

（2）新线程分离，但是主线程先退出就是代表进程退出，所有线程都会退出—— 一般我们分离线程，对应的main thread不要退出(常驻内存的进程)

六.线程互斥

1.三个概念

1.临界资源：多个执行流都能看到并能访问的资源，临界资源
2.临界区：多个执行流代码中有不同的代码，访问临界资源的代码，我们称之为临界区
3.互斥：当我们访问某种资源的时候，任何时刻。都只有一个执行流在进行访问，这个就叫做:互斥特性

2.互斥

没有互斥时，以抢票，票数减1： int tickets;   tickets--；为例

（1）在执行语句的任何地方，线程可能被切换走

int tickets;
tickets--；tickets--是由3条语句完成的：

tickets--:有三步
① load tickets to reg
② reg-- ;
③ write reg to tickets

（2）CPU内的寄存器是被所有的执行流共享的，但是寄存器里面的数据是属于当前执行流的上下文数据。线程被切换的时候，需要保存上下文；线程被换回的时候，需要恢复上下文。 

（3）抢票中的问题

线程A先抢到一张票时，寄存器中tickets 10000——>9999， 还未写回内存就被切走执行线程B了；线程B也抢票，直接抢了9950张，还剩50张，此时又切回线程A，又把9999写入内存，就错误了。

（4）解决方案

原子性：一件事要么不做，要么全做完

把tickets--这个临界区设为原子的，使不想被打扰，加锁

3.加锁

（1）加锁介绍

加锁范围：临界区,只要对临界区加锁，而且加锁的粒度约细越好

加锁本质：加锁的本质是让线程执行临界区代码串行化

加锁是一套规范，通过临界区对临界资源进行访问的时候，要加就都要加

锁保护的是临界区, 任何线程执行临界区代码访问临界资源，都必须先申请锁，前提是都必须先看到锁！那这把锁，本身不就也是临界资源吗？锁的设计者早就想到了

pthread_mutex_lock: 竞争和申请锁的过程，就是原子的！申请锁的过程不会中断，不会被打扰。

难度在加锁的临界区里面，就没有线程切换了吗？？？？

（2）定义/释放 互斥锁

man pthread_mutex_init

① pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 定义全局/静态的互斥锁，可以用这个宏初始化

② int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);         mutex：锁的地址。attr：锁的属性设为空
             

③ int pthread_mutex_destroy(pthread_mutex_t *mutex); 释放锁

（3）加锁、解锁

man pthread_mutex_lock

① int pthread_mutex_lock(pthread_mutex_t *mutex); 阻塞式申请的锁

线程1正在用这个阻塞锁，那线程2就要阻塞式等待线程1用完才能申请这个锁

② int pthread_mutex_trylock(pthread_mutex_t *mutex); 非阻塞式申请的锁

线程1正在用这个非阻塞锁，那线程2就直接返回，只有没有别的线程用这个锁，自己才能用

③ int pthread_mutex_unlock(pthread_mutex_t *mutex); 解锁

（4）使用锁代码

#include 
#include 
#include 
#include 
#include 
#include  // 仅仅是了解// __thread int global_value = 100;// void *startRoutine(void *args)
// {
//     // pthread_detach(pthread_self());
//     // cout << "线程分离....." << endl;
//     while (true)
//     {
//         // 临界区，不是所有的线程代码都是临界区
//         cout << "thread " << pthread_self() << " global_value: "
//              << global_value << " &global_value: " << &global_value
//              << " Inc: " << global_value++ << " lwp: " << ::syscall(SYS_gettid)<(args);while (true){// 临界区,只要对临界区加锁，而且加锁的粒度约细越好// 加锁的本质是让线程执行临界区代码串行化// 加锁是一套规范，通过临界区对临界资源进行访问的时候，要加就都要加// 锁保护的是临界区, 任何线程执行临界区代码访问临界资源，都必须先申请锁，前提是都必须先看到锁！// 这把锁，本身不就也是临界资源吗？锁的设计者早就想到了// pthread_mutex_lock: 竞争和申请锁的过程，就是原子的！// 难度在加锁的临界区里面，就没有线程切换了吗？？？？pthread_mutex_lock(&mutex);if (tickets > 0){usleep(1000);cout << name << " 抢到了票, 票的编号: " << tickets << endl;tickets--;pthread_mutex_unlock(&mutex);//other codeusleep(123); //模拟其他业务逻辑的执行}else{// 票抢到几张，就算没有了呢？0cout << name << "] 已经放弃抢票了，因为没有了..." << endl;pthread_mutex_unlock(&mutex);break;}}return nullptr;
}// 如何理解exit？
int main()
{pthread_mutex_init(&mutex, nullptr);pthread_t tid1;pthread_t tid2;pthread_t tid3;pthread_t tid4;pthread_create(&tid1, nullptr, getTickets, (void *)"thread 1");pthread_create(&tid2, nullptr, getTickets, (void *)"thread 2");pthread_create(&tid3, nullptr, getTickets, (void *)"thread 3");pthread_create(&tid4, nullptr, getTickets, (void *)"thread 4");// sleep(1);// 倾向于：让主线程，分离其他线程// pthread_detach(tid1);// pthread_detach(tid2);// pthread_detach(tid3);// 1. 立即分离,延后分离 -- 线程活着 -- 意味着，我们不在关心这个线程的死活。4. 线程退出的第四种方式，延后退出// 2. 新线程分离，但是主线程先退出(进程退出) --- 一般我们分离线程，对应的main thread一般不要退出(常驻内存的进程)// sleep(1);int n = pthread_join(tid1, nullptr);cout << n << ":" << strerror(n) << endl;n = pthread_join(tid2, nullptr);cout << n << ":" << strerror(n) << endl;n = pthread_join(tid3, nullptr);cout << n << ":" << strerror(n) << endl;n = pthread_join(tid4, nullptr);cout << n << ":" << strerror(n) << endl;pthread_mutex_destroy(&mutex);return 0;
}