linux多线程概念详述
Posted 命由己造～
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了linux多线程概念详述相关的知识，希望对你有一定的参考价值。
文章目录
一、线程基本概念
1.1 进程地址空间与页表
注意这里的页表部分：
在上一章【linux】进程信号——信号的保存和处理中我们讲了页表有用户级页表和内核级页表。如图其实页表还有其他很多属性。
举个例子：当我们对常量区的数据进行修改时，为什么会报错呢？
OS会先通过页表找到物理地址，然后查RWX权限，发现只有R权限，所以地址转换单元MMU会硬件报错，转化成信号，终止进程（段错误）。
而经过U/K权限的时候，如果是U就直接访问，是K就会去CPU查看当前的运行级别，是内核级别才能访问带K的映射关系。
那么该如何看待进程地址空间和页表呢？
1️⃣ 进程地址空间（虚拟内存）是进程能够看到的资源窗口。因为能看到的资源都是通过进程地址空间让我们看到的。
2️⃣ 页表是决定进程真正拥有资源的情况。
3️⃣ 合理的对进程地址空间+页表进行资源划分，就可以对进程的所有资源进行分类。
进程地址空间一共有2^32个地址。那么按道理页表也应该有2^32个条目，我们就当一个条目大小为1byte，也需要4GB的大小，更何况每个条目还得存很多数据。所以页表不可能会这么使用。
那么真实的页表到底是什么样子呢？
1.2 页表结构
首先说明几个点：
1️⃣ 进程地址空间的一个地址我们称为虚拟地址，有32个比特位。
2️⃣ 物理内存实际上也划分成了一个一个的数据页。OS为了管理每个数据页，每个数据页都有一个描述的结构体（非常小），存储内存的属性。每个页框大小为4KB
3️⃣ 磁盘上的可执行程序在被编译的时候也被划分成一个一个的4KB大小的数据块，我们把这种4KB的区域称为页帧。所以从磁盘加载到内存是以4KB为单位加载的。
虚拟地址的32个比特位并不是以一个整体转化的，而是分成10、10、12三块二进制构成。
而页表也不止一张，分为页目录、和页表。
先拿着虚拟地址的高十位去查页目录，比如如果是0000000001就是第二个位置，映射到指定的页表，再通过中间10个比特位确定物理内存中页框的起始地址，而一个页框的大小是4KB，有2^12字节，刚好对应虚拟地址的低12位比特位，就可以作为页内偏移量找到对应的位置。
这样我们在使用的时候有可能只使用了几个页表，那么其他的页表就不会加载到内存，只有需要的时候才会创建。由此解决了内存不足的问题。
1.3 线程的理解
首先要知道线程是进程内的一个执行流。
我们知道创建一个进程就会连着创建PCB，虚拟内存、页表。现在我们可以创建一个“进程”（PCB）直接指向虚拟内存，就像下边的绿色的task_struct。
例如代码区有一大段代码，我们现在就可以划分成几个小段代码，分给每个“进程”。这样就实现了资源的分配。
我们可以通过虚拟地址空间和页表对进程进行资源划分，而单个“进程”的执行力度一定要比之前一个进程要细。
1.3.1 如何描述线程
既然有多个线程，那么OS就会采取先描述后组织的方式进行管理。那么怎么描述呢？是创建一个新的结构体来描述吗？
我们知道PCB是用来描述进程的，那么描述线程的结构体我们叫做TCB（线程控制块）。
在windows中，就是新创建了一个结构体来描述线程。
而单纯的从线程调度角度，进程和线程有很多地方是重叠的。
所以在linux中，没有创建针对线程的数据结构，而是直接复用PCB，用PCB来表示线程。
而CPU在进行调度的时候不关注到底是进程还是线程，只看task_struct。
总结一下：线程在进程内部（进程的地址空间内）执行，拥有该进程的一部分资源。
1.4 再谈进程
什么叫做进程呢？
我们把红色框框圈起来的整体叫做进程：
PCB+进程地址空间+页表+加载到物理内存的代码和数据。
从内核角度：进程是承担分配系统资源的基本实体
在linux中：线程是CPU调度的基本单位
而在之前的文章讲过的进程【linux】进程概念详述它讲的是只有一个PCB的进程（只有一个执行流）。
今天所讲述的是一个进程内有多个执行流的情况。
从CPU角度：以前调度的就是一个进程，今天就是调度进程中的一个分支。
所以现在CPU统一把task_struct看作成轻量级进程。
我们知道linux没有正真意义的线程，这相比拥有真正线程的系统有什么优缺点呢？
优点：简单，维护成本大大降低，即可靠又高效。
缺点：linux无法直接提供线程的基本调用接口，只能提供创建轻量级进程的接口。
1.5 代码理解
1.5.1 原生库提供线程pthread_create
#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
Compile and link with -pthread.// 链接的时候必须加上-lpthread
RETURN VALUE
On success, pthread_create() returns 0;
on error, it returns an error number, and the contents of *thread are undefined.
参数说明：
thread：线程id
attr：线程属性，直接设为null
start_routine：函数指针
arg：这个参数会传递进start_routine的void*参数中。
这里在链接的时候要注意link到系统给的原生线程库-lpthread。
说明一下这个原生线程库：
因为用户只关注线程，但是OS不提供线程的接口，只提供创建轻量级进程的接口。所以在用户和OS之间加了一个用户级线程库。 向上提供各种线程接口，向下把对线程的各种操作转化为对轻量级进程的各种操作。
这个库在任何linux操作系统都默认存在。
// Makefile
mythread:mythread.cc
g++ -o $@ $^ -lpthread -std=c++11
.PHONY:clean
clean:
rm -f mythread
// mythread.cc
#include <iostream>
#include <pthread.h>
#include <cassert>
#include <unistd.h>
using std::cout;
using std::endl;
void* thread_stream(void *str)
while(true)
cout << "i am new thread" << endl;
sleep(1);
int main()
pthread_t tid;
int n = pthread_create(&tid, nullptr, thread_stream, (void*)"thread one");
assert(n == 0);
(void)n;
// 主线程
while(true)
cout << "i am main thread" << endl;
sleep(1);
return 0;
现象：运行了两个执行流，查看只有一个进程，杀死进程两个执行流全部被杀死。
如果想看到这两个轻量级线程：
使用指令：ps -aL
可以看到两个PID一样，说明属于同一个进程。而这里可以看到LWP不同，这里的LWP就表示轻量级进程ID。
细节：主线程的PID和LWP一样。
所以CPU在调度的时候用的就是LWP来作为标识符表示特定的执行流。
当只有一个单进程的时候PID和LWP是等价的。
那么这个tid到底是什么呢？
我们可以修改一下代码进行验证：
int main()
pthread_t tid;
int n = pthread_create(&tid, nullptr, thread_stream, (void*)"thread one ");
assert(n == 0);
(void)n;
// 主线程
while(true)
char buf[64];
snprintf(buf, sizeof(buf), "0x%x", tid);
cout << "i am main thread " << "tid: " << buf << endl;
sleep(1);
return 0;
这里只需要知道tid就是一个地址，后面会详细介绍。
1.6 资源共享问题
线程一旦被创建，几乎所有的资源都是被所有线程共享的。
比如：
文件描述符表
每种信号处理方式（SIG,IGN,SIG_DFL或者自定义信号处理函数）
当前工作目录
用户id和组id
#include <iostream>
#include <pthread.h>
#include <cassert>
#include <unistd.h>
#include <cstdio>
using std::cout;
using std::endl;
void fun()
cout << "这是一个独立的方法" << endl;
void* thread_stream(void *str)
while(true)
cout << "i am new thread, name: " << (const char*)str;
fun();
sleep(1);
int main()
pthread_t tid;
int n = pthread_create(&tid, nullptr, thread_stream, (void*)"thread one ");
assert(n == 0);
(void)n;
// 主线程
while(true)
char buf[64];
snprintf(buf, sizeof(buf), "0x%x", tid);
cout << "i am main thread " << "tid: " << buf;
fun();
sleep(1);
return 0;
可以看到这个函数可以被多个线程同时访问。
那么全局变量呢？
int cnt = 0;
void* thread_stream(void *str)
while(true)
cout << "i am new thread, name: " << (const char*)str << " cnt: " << cnt++ << " &cnt: " << &cnt << endl;
sleep(1);
int main()
pthread_t tid;
int n = pthread_create(&tid, nullptr, thread_stream, (void*)"thread one ");
assert(n == 0);
(void)n;
// 主线程
while(true)
char buf[64];
snprintf(buf, sizeof(buf), "0x%x", tid);
cout << "i am main thread " << "tid: " << buf << " cnt: " << cnt << " &cnt: " << &cnt << endl;
sleep(1);
return 0;
只要有一个线程中改变了，也会影响另一个进程。
由此可见线程之间通信非常容易。
但是这样又会引发另一个问题。
1.7 资源私有问题
线程也要有自己的私有资源，那么什么资源应该是线程所私有的呢？
1️⃣ PCB的属性（优先级，上下文（线程动态切换），状态……）。
2️⃣ 每一个线程都有自己独立的栈结构保存私有数据。
二、总结
2.1 什么是线程
笼统的讲：线程是在进程内部运行的一个执行分支（执行流），属于进程的一部分，粒度要比进程更加细致和轻量化。
- 在一个程序里的一个执行路线叫做线程，更准确的定义是：线程是”一个进程内部的控制序列“
- 一切进程至少都有一个执行线程
- 线程在进程内部运行，本质是在进程地址空间内运行
- 在Linux系统中，在CPU眼里，看到的PCB都要比传统的进程更加轻量化
- 透过进程虚拟地址空间，可以看到进程大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流。
2.2 并行与并发
并行：多个执行流在同一刻拿着不同的CPU进行运算。
并发：多个执行流在同一时刻只有一个执行流拥有CPU进行运算。
2.3 线程的优点
1️⃣ 创建线程的代价比创建进程小得多。因为不用创建地址空间、页表、加载代码数据，只用创建一个PCB指向进程地址空间就够了。
2️⃣ 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多。
进程要切换 页表、PCB、虚拟地址空间……
而线程切换只用切换PCB
那么他们做的工作量到底差距在哪里呢？
在CPU中有一块高速缓存cache，它的效率比寄存器慢，但比内存快。它有局部性原理：当前访问代码附近的代码数据也会被加载进来，有较大的概率被访问到。CPU不会从内存中直接读取数据，而是从cache中获取，没有命中就再从内存中加载数据到cache。而一个已经运行一段时间的进程cache内部会有很多“热点数据”，线程切换的时候并不会更新chche的数据（因为这些热点数据本来就是被线程所共享的），但是进程切换的时候chache内的数据立刻更新。这样chache又得重新缓存数据。
3️⃣ 线程的占有资源比进程小得多。
4️⃣ 能充分利用多处理器的可并行数量。
5️⃣ 在等待慢速I/O操作结束的同时，程序可执行其他的计算任务。
6️⃣ 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现。计算密集型应用最常见的情况有：加密，大数据运算等—主要使用的是CPU资源。
7️⃣ I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。
2.4 线程的缺点
1️⃣ 性能损失
一个很少被外部事件阻塞的计算密集型线程往往无法与共它线程共享同一个处理器。如果计算密集型线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变。
2️⃣ 健壮性(鲁棒性)降低
编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的。
验证：一个线程出现异常会影响其他线程吗？
void* thread_stream(void *str)
while(true)
cout << "i am new thread, name: " << (const char*)str << endl;
sleep(1);
// 一个线程出现异常
int* p = nullptr;
*p = 100;
int main()
pthread_t tid;
int n = pthread_create(&tid, nullptr, thread_stream, (void*)"thread one ");
assert(n == 0);
(void)n;
// 主线程
while(true)
char buf[64];
snprintf(buf, sizeof(buf), "0x%x", tid);
cout << "i am main thread " << "tid: " << buf << endl;
sleep(1);
return 0;
原因：线程出现了异常，OS就会发送信号到进程中，这个信号是发送给进程整体的，所以所有线程都会退出。
3️⃣ 缺乏访问控制
进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。
4️⃣ 编程难度提高
编写与调试一个多线程程序比单线程程序困难得多
2.5 线程异常
1️⃣ 单线程如果出现除零或野指针问题导致线程崩溃，进程也会跟着崩溃。
2️⃣ 因为进程具有独立性，导致其他进程最多只是对该进程只读但是不能写。而线程共用的是一个进程的地址空间，线程与线程之间的数据可以互相访问，当一个线程数据出错了，操作系统对该线程发信号，发信号只能发送给该线程对应的进程，进程跟着崩溃了，导致进程内的所有数据被释放，该进程内的其他线程也跟着销毁了（因为线程的数据是进程给的）。所以一个线程崩溃就会导致整个进程崩溃，这也造成了线程的健壮性降低的原因。
2.6 进程与线程间的关系
1️⃣ 进程是系统资源分配的基本单位，线程是系统调度的基本单位。
2️⃣ 一个进程中有多个线程，或至少有一个线程。
3️⃣ 系统只会给进程分配资源，而不会给线程分配资源。
2.7 进程ID（tgid）与线程ID（pid）
没有线程之前，一个进程对应内核里的一个进程描述符，对应一个进程ID。但是引入线程概念之后，情况发生了变化，一个用户进程下管辖N个用户态线程，每个线程作为一个独立的调度实体在内核态都有自己的进程描述符，进程和内核的描述符一下子就变成了1：N关系，POSIX标准又要求进程内的所有线程调用getpid函数时返回相同的进程ID，如何解决上述问题呢？
所以引入了线程组的概念。
多线程的进程，又被称为线程组，线程组内的每一个线程在内核之中都存在一个进程描述符（task_struct）与之对应。进程描述符结构体中的pid，表面上看对应的是进程ID，其实不然，它对应的是线程ID;进程描述符中的tgid，含义是Thread Group ID,该值对应的是用户层面的进程ID。现在介绍的线程ID，不同于pthread_t类型的线程ID，和进程ID一样，线程ID是pid_t类型的变量，是用来唯一标识线程的一个整型变量。
我们要清楚，在系统层面只有两个编号：pid、tgid。
不妨拿出task_struct结构体（进程PCB）看一看：
pid_t pid;
pid_t tgid;
我们知道，在linux中进程和线程都使用task_struct结构体实现。
在task_struct中：
pid即线程id。也就是task_struct的编号，每个task_struct各不相同。
tgid叫线程组id。也就是一个进程的id。同一个进程里每一个线程的task_struct中tgid值都一样。
双线程猜数字 （java多线程习题详述）
双线程猜数字 java多线程习题详述
文章目录
1、实验要求：
用两个线程玩猜数字游戏，第一个线程负责随机给出1到100之间的一个整数，第二个线程负责猜出这个数。要求每当第二个线程给出自己的猜测后，第一个线程都会提示“猜小了”、“猜大了”或“猜对了”。猜数之前，要求第二个线程要等待第一个线程设置好要猜测的数。第一个线程设置好猜测数之后，两个线程还要互相等待，其原则是，第二个线程给出自己的猜测后，等待第一个线程给出的提示；第一个线程给出提示后，等待给第二个线程给出猜测，如此进行，直到第二个线程给出正确的猜测后，两个线程进入死亡状态。
2、代码
package Thread1;
public class TwoThreadGuessNumber
public static void main(String[] args)
Number number=new Number();
number.giveNumberThread.start();
number.guessNumberThread.start();
package Thread1;
public class Number implements Runnable
final int SMALLER=-1,LARGER=1,SUCCESS=8;
int realNumber,guessNumber,min=0,max=100,message=SMALLER;
boolean pleaseGuess=false,isGiveNumber=false;
Thread giveNumberThread,guessNumberThread;
Number()
giveNumberThread= new Thread(this);
guessNumberThread= new Thread(this);
//【代码1】创建giveNumberThread,当前Number类的实例是giveNumberThread的目标对象
//【代码2】创建guessNumberThread,当前Number类的实例是guessNumberThread的目标对象
public void run()
for(int count=1;true;count++)
setMessage(count);
if( message==SUCCESS)
return;
public synchronized void setMessage(int count)
if(Thread.currentThread()==giveNumberThread&&isGiveNumber==false)
realNumber=(int)(Math.random()*100)+1;
System.out.println("随机给你一个1至100之间的数，猜猜是多少？");
isGiveNumber=true;
pleaseGuess=true;
if(Thread.currentThread()==giveNumberThread)
while(pleaseGuess==true)
try wait(); //让出CPU使用权，让另一个线程开始猜数
catch(InterruptedException e)
if(realNumber>guessNumber) //结束等待后，根据另一个线程的猜测给出提示
message=SMALLER;
System.out.println("你猜小了");
else if(realNumber<guessNumber)
message=LARGER;
System.out.println("你猜大了");
else
message=SUCCESS;
System.out.println("恭喜，你猜对了");
pleaseGuess=true;
if(Thread.currentThread()==guessNumberThread&&isGiveNumber==true)
while(pleaseGuess==false)
try wait(); //让出CPU使用权，让另一个线程给出提示
catch(InterruptedException e)
if(message==SMALLER)
min=guessNumber;
guessNumber=(min+max)/2;
System.out.println("我第"+count+"次猜这个数是:"+guessNumber);
else if(message==LARGER)
max=guessNumber;
guessNumber=(min+max)/2;
System.out.println("我第"+count+"次猜这个数是:"+guessNumber);
pleaseGuess=false;
notifyAll();
运行结果：
随机给你一个1至100之间的数，猜猜是多少？
我第1次猜这个数是:50
你猜小了
我第2次猜这个数是:75
你猜大了
我第3次猜这个数是:62
你猜小了
我第4次猜这个数是:68
恭喜，你猜对了
进程已结束，退出代码 0
3、遇到的问题及解决办法
3.1、如何生成1~100的随机整数
Java random() 方法
random()方法用于返回一个随机数，随机数范围为 0.0 =< Math.random < 1.0
语法：
static double random()
参数：
这是一个默认方法，不接受任何参数。
返回值
该方法返回 double 值。
实例：
public class Test
public static void main(String args[])
System.out.println( Math.random() );
System.out.println( Math.random() );
3.2、如何让两个线程互相联系
线程通信
为了实现线程一与线程二之间的联系，采用线程通信的方式。（wait和notify）
概述：
线程与线程之间不是相互独立的个体，它们彼此之间需要相互通信和协作，虽然两个线程实现了通信，但是凭借线程B不断地通过while语句轮询来检测某一个条件，这样会导致CPU的浪费。因此，需要一种机制来减少CPU资源的浪费，而且还能实现多个线程之间的通信，即 wait/notify 机制。
wait/notify 机制
1.wait()——让当前线程 (Thread.concurrentThread() 方法所返回的线程) 释放对象锁并进入等待（阻塞）状态。
2.notify()——唤醒一个正在等待相应对象锁的线程，使其进入就绪队列，以便在当前线程释放锁后竞争锁，进而得到CPU的执行。
3.notifyAll()——唤醒所有正在等待相应对象锁的线程，使它们进入就绪队列，以便在当前线程释放锁后竞争锁，进而得到CPU的执行。
4、总结（报告中的实验内容）
使用Thread创建线程对象时，通常使用的构造方法是：
Thread(Runnable target);
该构造方法中的参数是一个Runnable类型的接口，因此，在创建线程对象时必须向构造方法的参数传递一个实现Runnable接口类的实例，该实例对象称作所创线程的目标对象。当线程调用start方法后，一旦轮到它来享用CPU资源，目标对象就会自动调用接口中的run方法（接口回调），这一过程是自动实现的，用户程序只需要让线程调用start方法即可。线程绑定于Runnable接口，也就是说，当线程被调度并转入运行状态时，所执行的就是run()方法中所规定的操作。
线程同步是指几个线程都需要调用同一个同步方法（用synchronized修饰的方法）。一个线程在使用的同步方法中时，可能根据问题的需要，必须使用wait()方法暂时让出CPU的使用权，以便其它线程使用这个同步方法。其它线程如果在使用这个同步方法时如果不需要等待，那么它用完这个同步方法的同时，应当执行notifyAll()方法通知所有的由于使用这个同步方法而处于等待的线程结束等待。曾中断的线程就会从刚才的中断处继续执行这个同步方法，并遵循“先中断先继续”的原则。如果使用notify()方法，那么只是通知处于等待中的线程的某一个结束等待。wait（）、notify（）和notifyAll（）都是Object类中的final方法，被所有的类继承、且不允许重写的方法
5、想要更深入的了解多线程
如果小伙伴想要更加深入的了解多线程，点击此黄色字体链接，java多线程详解教程,相信您会有更大的收获。
以上是关于linux多线程概念详述的主要内容，如果未能解决你的问题，请参考以下文章