//本文部分图片来源于网络，侵权联系删除
一、基础部分
1.什么是线程：
是进程中的一个运行实体，也可以理解为进程中开辟出的一条新道路，早期的线程被称为轻量级进程。
进程是顺序执行体，但是有了线程，就可以在半路开一条新道路，去执行新的任务。
2.为什么要引用线程：
很简单，我们希望一个应用程序同时做多件事，并且充分的将资源利用起来。
一般情况下，不论选择多线程还是多进程，都是以效率为首的：
进程的复杂操作：
创建进程
撤销进程
进程之间的通信
进程的切换
弊端：时间/开销大，限制并发度的提高
线程开销小：
创建和撤销线程时间短
线程之间切换开销小，因为是在同一个地址空间中
线程之间通信无须内核的介入，因为同一进程之间的线程共享内存和资源
优点：开销小，效率高
弊端：需要同步操作较多，一个线程的崩溃会导致整个应用程序的崩溃
3.线程的属性：
标识符 TID
线程控制块TCB
有状态以及状态的转移
不运行时需要保存上下文（线程的切换等，包含程序计数器等寄存器）
有自己独立的栈和栈指针
所有线程共享所在进程的地址空间和其他资源
程序开始总是由一个单线程进程运行，最终其他线程的由主线程创建或者撤销
4.线程的几种实现模型
1.用户级线程模型：在用户空间建立线程库，提供线程的管理。
实现在用户空间的线程，所以内核看到的还是一个进程，不知道线程的存在
所以线程的切换不需要内核态特权
UNIX这样实现：POSIX标准，提供线程库pthread
优点：
线程的切换快，调度算法由编程者自己实现，而与内核无关
只要提供线程库，就可以在任意操作系统是运行
缺点：
”表面多线程“，在内核看来，只能看到一个进程，看不到进程中创建的线程，但是用户看到了
因为用户级线程创建没有经过OS，所以没有创建相应的内核数据结构如TCB，内核根本感知不到
一个”线程阻塞“，整个进程阻塞
（jacketing技术，将一个会阻塞的系统调用转换成不阻塞的系统调用）
所以，操作系统不可能把这个进程中的”线程“分配到不同的处理器上，因为OS只能看到用户空间的这个进程
2.内核级线程模型
特点：
内核管理所有的线程，向用户提供API
内核维护进程和线程的上下文
线程的切换需要内核的支持
OS以线程为基础进行调用
优点：
内核级线程才是处理机分配的单位，是内核支持的线程，
内核真正感知到的，可以进程调度的分配的线程，多线程开发中常用的
3.混合线程模型：
线程创建在用户空间完成，线程调度等在核心态完成
将用户的线程 和 内核的线程通过多路复用或者其他机制将 对应起来
将用户线程要做的事转交给内核线程
posix线程调度是一个混合模型，在标准的特定实现中支持用户级和内核级的线程。模型中包括两级调度–线程及和内核实体级。线程级与用户级线程类似，内核实体由内核调度。由线程库来决定它需要多少内核实体，以及他们是如何映射的。
缺点：
不容易实现
二、linux中线程：
1.实际写一个多线程使用：
实例1：创建一个线程，执行工作
#include<stdio.h>
#inlcude<stdlib.h>
void *work_thread()
{
int i=0;
for(;i<5;i++)
{
printf(“ work_pthread run \n”);
sleep(1);
}
pthread_exit(“pthread over\n”);
}
int main()
{
pthread_t id;
pthread_create(&id,NULL,work_thread,NULL);
int i=0;
for(;i<2;i++)
{
printf(“main run \n”);
sleep(1);
}
pthread_join(id,（void**）&s);
//s指的被合并线程所返回的信息
//执行到这里 主线程将阻塞 等待work_thread子线程执行完 接着一起向下执行
//如果打印s s=pthread over
exit(0);
}
编译时链接库：
gcc -o main main.c -lpthread
示例2：创建多个线程操作一个数字，不使用任何同步机制
#define MAX 5
int g =0;
void *fun(void * argv)
{
int i=0;
for(;i<1000;i++)
{
g++;
printf(“g=%d\n”,g);
}
}
int main()
{
pthread_t id[MAX];
int i=0;
for(;i<MAX,;i++)
{
pthread_create(&id[i],NULL,fun,NULL);
}
int i=0;
for(;i<2;i++)
{
printf(“main run \n”);
sleep(1);
}
pthread_join(id,（void**）&s)
}
示例3：创建多个线程操作一个数字，使用锁同步机制
#define MAX 5
int g =0;
pthread_mutex_t mutex;//定义互斥锁
void *fun(void * argv)
{
int i=0;
for(;i<1000;i++)
{
pthread_mutex_lock;
g++;
pthread_mutex_unlock;
printf(“g=%d\n”,g);
}
}
int main()
{
pthread_t id[MAX];
int i=0;
pthread_mutex_init;//初始化
for(;i<MAX,;i++)
{
pthread_create(&id[i],NULL,fun,NULL);
}
int i=0;
for(;i<2;i++)
{
printf(“main run \n”);
sleep(1);
}
pthread_join(id,（void**）&s)
}
前面提到了，对于同一个进程中的线程实际上是共享进程地址空间的，所以当多个进程去写同一个数据时，必然会产生竞争，需要我们进行同步，使得多个线程异步的访问共享数据。
一个进程中存在多个线程，线程与线程之间没有比如联系，独立运行；
当一个线程崩溃会引起整个进程的奔溃，一个线程调用exit，整个进程将退出；
这里添加一个链接，常用的线程函数这里有详细的讲解：https://www.jianshu.com/p/fc2446b3fa94
2.可重入函数：
多次执行，不会对执行结果有影响
比如linux上字符串切割函数：strtok()
该函数在实现中用到了静态数据，所以被多个线程执行，每次结果不同
linux提供了相应的安全版本：strtok_r()
3.当多线程遭遇了fork():
本部分内容原文链接：https://blog.csdn.net/cywosp/article/details/27316803
在多线程执行的情况下调用fork()函数，仅会将发起调用的线程复制到子进程中。
（子进程中该线程的ID与父进程中发起fork()调用的线程ID是一样的，因此，线程ID相同的情况有时我们需要做特殊的处理。）也就是说不能同时创建出于父进程一样多线程的子进程。其他线程均在子进程中立即停止并消失，并且不会为这些线程调用清理函数以及针对线程局部存储变量的析构函数。这将导致下列一些问题:
1. 虽然只将发起fork()调用的线程复制到子进程中，但全局变量的状态以及所有的pthreads对象（如互斥量、条件变量等）都会在子进程中得以保留，这就造成一个危险的局面。
例如：一个线程在fork()被调用前锁定了某个互斥量，且对某个全局变量的更新也做到了一半，
此时fork()被调用，所有数据及状态被拷贝到子进程中，
那么子进程中对该互斥量就无法解锁（因为其并非该互斥量的属主），
如果再试图锁定该互斥量就会导致死锁，这是多线程编程中最不愿意看到的情况。
同时，全局变量的状态也可能处于不一致的状态，
因为对其更新的操作只做到了一半对应的线程就消失了。
fork()函数被调用之后，子进程就相当于处于signal handler之中，
此时就不能调用线程安全的函数（用锁机制实现安全的函数），
除非函数是可重入的，而只能调用异步信号安全（async-signal-safe）的函数。
fork()之后，子进程不能调用：
malloc(3)。因为malloc()在访问全局状态时会加锁。
任何可能分配或释放内存的函数，包括new、map::insert()、snprintf() ……
任何pthreads函数。你不能用pthread_cond_signal()去通知父进程，只能通过读写pipe(2)来同步。
printf()系列函数，因为其他线程可能恰好持有stdout/stderr的锁。
除了man 7 signal中明确列出的“signal安全”函数之外的任何函数。
2. 因为并未执行清理函数和针对线程局部存储数据的析构函数，所以
多线程情况下可能会导致子进程的内存泄露。
另外，子进程中的线程可能无法访问（父进程中）由其他线程所创建的线程局部存储变量，
因为（子进程）没有任何相应的引用指针。
推荐在多线程程序中调用fork()的唯一情况是：其后立即调用exec()函数执行另一个程序，彻底隔断子进程与父进程的关系。由新的进程覆盖掉原有的内存，使得子进程中的所有pthreads对象消失。
4.linux下的线程是怎么产生的：sys_clone()
线程的本质：实际上就是与主线程共享地址空间的进程
在说直白一点，就是一个和调用pthred_create()进程 共享 地址空间的进程
线程本质上就是一个进程，只不过其他进程共享了虚拟地址空间
好处：这样资源的分配、上下文的切换，开销大大减少，只给线程分配相应的堆栈即可。
缺点：一个线程的崩溃可能造成整个进程的崩溃，线程间的互斥操作较多
所以你觉得线程是怎么产生的？
asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
int __user *parent_tidptr, int tls_val,
int __user *child_tidptr, struct pt_regs *regs)
{
if (!newsp)
newsp = regs->ARM_sp;
return do_fork(clone_flags, newsp, regs, 0, parent_tidptr, child_tidptr);
}
sys_clone()调用的是do_fork(),这是不是就和我们的sys_fork()产生进程调用的函数一致。
说明的问题不言而喻。
三、线程间的同步互斥问题：
1.同步和互斥：
互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源。
2.为什么要进行互斥：
举个例子：
对于全局变量i =0;
现在有俩个线程A、B，都执行i+1的操作 理想状态是经过执行后i的值是2；
可能出现的情况:
线程A把i=0读到自己的寄存器（此时A线程还没有来得及将内存里的i更新为1），
同时线程B把i=0也读到了自己的寄存器，此时同时都进行+1操作
不难得出最终内存中的i值是1；
线程修改数据的一般过程：
（1）从内存单元读入寄存器。
（2）在寄存器中进行变量值的增加。
（3）把新的值写回内存单元。
3.同步与互斥的机制:
临界资源：同一时刻，只允许一个进程或者线程访问使用的资源，可以是一台打印机，也可以是一个整型数字，还可以是一个文件等等
临界区：用来访问临界资源的一段代码
互斥锁：我们在访问共享变量时，加一把锁，其他线程向访问该变量，得等待，知道当前线程释放锁。
int pthread_mutex_init
(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); //初始化互斥量
int pthread_mutex_destroy(pthread_mutex_t *mutex); //回收非配给该互斥量的资源
int pthread_mutex_lock(pthread_mutex_t *mutex); //对互斥量加锁
int pthread_mutex_trylock(pthread_mutex_t *mutex); //尝试加锁
int pthread_mutex_unlock(pthread_mutex_t *mutex); //释放加在互斥量上的锁
互斥量，它只有两个状态，要么是加锁状态，要么是不加锁。
读写锁：
1）多个读者可以同时进行读
2）写者必须互斥（只允许一个写者写，也不能读者写者同时进行）
3）写者优先于读者（一旦有写者，则后续读者必须等待，唤醒时优先考虑写者）
int pthread_rwlock_init
(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr); //初始化读写锁
int pthread_rwlock_deatroy(pthread_rwlock_t *rwlock); //回收非配给读写锁的资源
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); //读模式加锁
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); //写模式加锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); //释放锁
下面这两个函数为尝试加锁，当可以加锁时，会获得锁,不可以时不会阻塞而是返回错误EBUSY
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlick_trywrlock(pthread_rwlock_t *rwlock)；
读操作不会造成竞态，不会发生什么以外情况
写操作一定要互斥的访问临界资源
还有一些其他的同步机制：如条件变量、自旋锁等
4.关键字volatitle和barrier():
volatitle:
1.防止线程缓存全局变量，使线程每次去内存中取值，而不是将数据缓存到自己的寄存器
2.防止编译器的进行数据指令上顺序上的调优，产生不可预知的结果
线程修改数据的一般过程：
（1）从内存单元读入寄存器。
（2）在寄存器中进行变量值的增加。
（3）把新的值写回内存单元。
volatitle 能使得线程对数据不进行缓存，每次去内存中取值，而不是使用缓存下来的值
barrier()：内存屏障
防止 CPU 在执行的过程中，对指令进行顺序上的调优
2613
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
