linux进程线程调度

‘壹’ linux进程与线程的区别

很多朋友都想知道linux进程与线程的区别？下面就一起来了解一下吧！

linux进程与线程的区别

进程是在某个数据知雹者集合上具有独立功能的一次运行活动，也是系统进行资源肆档分配和调度的一个独立单位。线程在进程方面属于进程的实体，是CPU调度和分配的基本单位，基本上线程自己没有拥有任何的系统资源搭薯，只拥有一点在运行中必备的资源（如程序计数器、一组寄存器和栈），但是它可以与同属一个进程的线程共享资源。

Linux的用处

linux是一套免费开放源代码的操作系统，用户可以按照自己的想法来修改源代码，它的每一个操作，你都能够充分了解，这对计算机方面的爱好者是有很大帮助的，它可以让用户知道系统是怎样工作的。

Linux的语言

linux开发用的是C语言和汇编语言。C语言是Linux的“母语”，这也是linux这个开源环境和本身机制所导致的。Linux的内核部分基本都是用C语言来编写的，还有部分是用汇编语言写的。

本文章基于ThinkpadE15品牌、centos7系统撰写的。

‘贰’ Linux 进程、线程和CPU的关系，cpu亲和性

1、物理CPU数：机器主板上实际插入的cpu数量，比如说你的主板上安装了一块8核CPU，那么物理CPU个数就是1个，所以物理CPU个数就是主板上安装的CPU个数。

2、物理CPU核数：单个物理CPU上面有多个核，物理CPU核数=物理CPU数✖️单个物理CPU的核
3、逻辑CPU核数：一般情况，我们认为一颗CPU可以有多个核，加上intel的超线程技术(HT), 可以在逻辑上再分一倍数量的CPU core出来。逻辑CPU核数=物理CPU数✖️单个物理CPU的核*2
4、超线程技术(Hyper-Threading)：就是利用特殊的硬件指令，把两个逻辑CPU模拟成两个物理CPU，实现多核多线程。我们常听到的双核四线程/四核八线程指的就是支持超线程技术的CPU。

1、并行：两件（多件）事情在同一时刻一起发生。
2、并发：两件（多件）事情在同一时刻只能有一个发生，由于CPU快速切换，从而给人的感觉是同时进行。
3、进程和线程
进程是资源分配的最小单位，一个程序有至少一个进程。线程是程序执行的最小单位。一个进程有至少一个线程。
线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式（IPC)进行。多进程程序更健壮，多线程程序只要有一个线程死掉，整个进程也死掉了，而一个进程死掉并不会对另外一个进程造成影响，因为进程有自己独立的地址空间。
4、单核多线程：单核CPU上运行多线程， 同一时刻只有一个线程在跑，系统进行线程切换，系统给每个线程分配时间片来执行，看起来就像是同时在跑， 但实际上是每个线程跑一点点就换到其它线程继续跑。
5、多核多线程：每个核上各自运行线程，同一时刻可以有多个线程同时在跑。

1、对于单核：多线程和多进程的多任务是在单cpu交替执行（时间片轮转调度，优先级调度等），属于并发
2、对于多核：同一个时间多个进程运行在不同的CPU核上，或者是同一个时间多个线程能分布在不同的CPU核上（线程数小于内核数），属于并行。
3、上下文切换：上下文切换指的是内核（操作系统的核心）在CPU上对进程或者线程进行切换。上下文切换过程中的信息被保存在进程控制块（PCB-Process Control Block）中。PCB又被称作切换帧（SwitchFrame）。上下文切换的信息会一直被保存在CPU的内存中，直到被再次使用。

CPU 亲和性（affinity）就是进程要在某个给定的 CPU 上尽量长时间地运行而不被迁移到其他处理器的倾向性。这样可以减少上下文切换的次数，提高程序运行性能。可分为：自然亲和性和硬亲和性
1、自然亲和性：就是进程要在指定的 CPU 上尽量长时间地运行而不被迁移到其他处理器，Linux 内核进程调度器天生就具有被称为 软 CPU 亲和性（affinity） 的特性，这意味着进程通常不会在处理器之间频繁迁移。这种状态正是我们希望的，因为进程迁移的频率小就意味着产生的负载小。Linux调度器缺省就支持自然CPU亲和性(natural CPU affinity): 调度器会试图保持进程在相同的CPU上运行。
2、硬亲和性：简单来说就是利用linux内核提供给用户的API，强行将进程或者线程绑定到某一个指定的cpu核运行。Linux硬亲和性指定API：taskset .

taskset [options] mask command [arg]...
taskset [options] -p [mask] pid

taskset 命令用于设置或者获取一直指定的 PID 对于 CPU 核的运行依赖关系。也可以用 taskset 启动一个命令，直接设置它的 CPU 核的运行依赖关系。

CPU 核依赖关系是指，命令会被在指定的 CPU 核中运行，而不会再其他 CPU 核中运行的一种调度关系。需要说明的是，在正常情况下，为了系统性能的原因，调度器会尽可能的在一个 CPU 核中维持一个进程的执行。强制指定特殊的 CPU 核依赖关系对于特殊的应用是有意义的
CPU 核的定义采用位定义的方式进行，最低位代表 CPU0，然后依次排序。这种位定义可以超过系统实际的 CPU 总数，并不会存在问题。通过命令获得的这种 CPU 位标记，只会包含系统实际 CPU 的数目。如果设定的位标记少于系统 CPU 的实际数目，那么命令会产生一个错误。当然这种给定的和获取的位标记采用 16 进制标识。
0x00000001
代表 #0 CPU
0x00000003
代表 #0 和 #1 CPU
0xFFFFFFFF
代表 #0 到 #31 CPU

-p, --pid
对一个现有的进程进行操作，而不是启动一个新的进程
-c, --cpu-list
使用 CPU 编号替代位标记，这可以是一个列表，列表中可以使用逗号分隔，或者使用 "-" 进行范围标记，例如：0,5,7,9
-h, --help
打印帮助信息
-V, --version
打印版本信息

如果需要设定，那么需要拥有 CAP_SYS_NICE 的权限；如果要获取设定信息，没有任何权限要求。

taskset 命令属于 util-linux-ng 包，可以使用 yum 直接安装。

‘叁’ 请教linux下用户态进程调度问题

在进行Linux系统操作的时候，有时候会遇到一次用户态进程死循环，即系统反应迟钝、进程挂死等问题，那么遇到这些问题又该如何解决呢？下面小编就给大家介绍下一次用户态进程死循环的问题该如何处理。
Linux下如何处理一次用户态进程死循环问题
1、问题现象
业务进程（用户态多线程程序）挂死，操作系统反应迟钝，系统日志没有任何异常。从进程的内核态堆栈看，看似所有线程都卡在了内核态的如下堆栈流程中：
［root@vmc116 ~］# cat /proc/27007/task/11825/stack
［《ffffffff8100baf6》］ retint_careful+0x14/0x32
［《ffffffffffffffff》］ 0xffffffffffffffff
2、问题分析
1）内核堆栈分析
从内核堆栈看，所有进程都阻塞在 retint_careful上，这个是中断返回过程中的流程，代码（汇编）如下：
entry_64.S
代码如下：
ret_from_intr：
DISABLE_INTERRUPTS（CLBR_NONE）
TRACE_IRQS_OFF
decl PER_CPU_VAR（irq_count）
/* Restore saved previous stack */
popq %rsi
CFI_DEF_CFA rsi，SS+8-RBP /* reg/off reset after def_cfa_expr */
leaq ARGOFFSET-RBP（%rsi）， %rsp
CFI_DEF_CFA_REGISTER rsp
CFI_ADJUST_CFA_OFFSET RBP-ARGOFFSET
。。。
retint_careful：
CFI_RESTORE_STATE
bt $TIF_NEED_RESCHED，%edx
jnc retint_signal
TRACE_IRQS_ON
ENABLE_INTERRUPTS（CLBR_NONE）
pushq_cfi %rdi
SCHEDULE_USER
popq_cfi %rdi
GET_THREAD_INFO（%rcx）
DISABLE_INTERRUPTS（CLBR_NONE）
TRACE_IRQS_OFF
jmp retint_check
这其实是用户态进程在用户态被中断打断后，从中断返回的流程，结合retint_careful+0x14/0x32，进行反汇编，可以确认阻塞的点其实就在
SCHEDULE_USER
这其实就是调用schele（）进行调度，也就是说当进程走到中断返回的流程中时，发现需要调度（设置了TIF_NEED_RESCHED），于是在这里发生了调度。
有一个疑问：为什么在堆栈中看不到schele（）这一级的栈帧呢？
因为这里是汇编直接调用的，没有进行相关栈帧压栈和上下文保存操作。
2）进行状态信息分析
从top命令结果看，相关线程实际一直处于R状态，CPU几乎完全耗尽，而且绝大部分都消耗在用户态：
［root@vmc116 ~］# top
top - 09:42:23 up 16 days， 2:21， 23 users， load average： 84.08， 84.30， 83.62
Tasks： 1037 total， 85 running， 952 sleeping， 0 stopped， 0 zombie
Cpu（s）： 97.6%us， 2.2%sy， 0.2%ni， 0.0%id， 0.0%wa， 0.0%hi， 0.0%si， 0.0%st
Mem： 32878852k total， 32315464k used， 563388k free， 374152k buffers
Swap： 35110904k total， 38644k used， 35072260k free， 28852536k cached
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
27074 root 20 0 5316m 163m 14m R 10.2 0.5 321:06.17 z_itask_templat
27084 root 20 0 5316m 163m 14m R 10.2 0.5 296:23.37 z_itask_templat
27085 root 20 0 5316m 163m 14m R 10.2 0.5 337:57.26 z_itask_templat
27095 root 20 0 5316m 163m 14m R 10.2 0.5 327:31.93 z_itask_templat
27102 root 20 0 5316m 163m 14m R 10.2 0.5 306:49.44 z_itask_templat
27113 root 20 0 5316m 163m 14m R 10.2 0.5 310:47.41 z_itask_templat
25730 root 20 0 5316m 163m 14m R 10.2 0.5 283:03.37 z_itask_templat
30069 root 20 0 5316m 163m 14m R 10.2 0.5 283:49.67 z_itask_templat
13938 root 20 0 5316m 163m 14m R 10.2 0.5 261:24.46 z_itask_templat
16326 root 20 0 5316m 163m 14m R 10.2 0.5 150:24.53 z_itask_templat
6795 root 20 0 5316m 163m 14m R 10.2 0.5 100:26.77 z_itask_templat
27063 root 20 0 5316m 163m 14m R 9.9 0.5 337:18.77 z_itask_templat
27065 root 20 0 5316m 163m 14m R 9.9 0.5 314:24.17 z_itask_templat
27068 root 20 0 5316m 163m 14m R 9.9 0.5 336:32.78 z_itask_templat
27069 root 20 0 5316m 163m 14m R 9.9 0.5 338:55.08 z_itask_templat
27072 root 20 0 5316m 163m 14m R 9.9 0.5 306:46.08 z_itask_templat
27075 root 20 0 5316m 163m 14m R 9.9 0.5 316:49.51 z_itask_templat
。。。
3）进程调度信息
从相关线程的调度信息看：
［root@vmc116 ~］# cat /proc/27007/task/11825/schedstat
15681811525768 129628804592612 3557465
［root@vmc116 ~］# cat /proc/27007/task/11825/schedstat
15682016493013 129630684625241 3557509
［root@vmc116 ~］# cat /proc/27007/task/11825/schedstat
15682843570331 129638127548315 3557686
［root@vmc116 ~］# cat /proc/27007/task/11825/schedstat
15683323640217 129642447477861 3557793
［root@vmc116 ~］# cat /proc/27007/task/11825/schedstat
15683698477621 129645817640726 3557875
发现相关线程的调度统计一直在增加，说明相关线程一直是在被调度运行的，结合其状态也一直是R，推测很可能在用户态发生了死循环（或者非睡眠死锁）。
这里又有问题：为什么从top看每个线程的CPU占用率只有10%左右，而不是通常看到的死循环进程导致的100%的占用率？
因为线程数很多，而且优先级都一样，根据CFS调度算法，会平均分配时间片，不会让其中一个线程独占CPU。结果为多个线程间轮流调度，消耗掉了所有的cpu。。
另一个问题：为什么这种情况下，内核没有检测到softlockup？
因为业务进程的优先级不高，不会影响watchdog内核线程（最高优先级的实时线程）的调度，所以不会产生softlockup的情况。
再一个问题：为什么每次查看线程堆栈时，总是阻塞在retint_careful，而不是其它地方？
因为这里（中断返回的时候）正是调度的时机点，在其它时间点不能发生调度（不考虑其它情况~），而我们查看线程堆栈的行为，也必须依赖于进程调度，所以我们每次查看堆栈时，正是查看堆栈的进程（cat命令）得到调度的时候，这时正是中断返回的时候，所以正好看到的阻塞点为retint_careful。
4）用户态分析
从上面的分析看，推测应该是用户态发生了死锁。
用户态确认方法：
部署debug信息，然后gdb attach相关进程，确认堆栈，并结合代码逻辑分析。
最终确认该问题确为用户态进程中产生了死循环。

‘肆’ Linux中常见IO调度器

对于磁盘I/O，Linux提供了cfq, deadline和noop三种调度策略

考虑到硬件配置、实际应用场景（读写比例、顺序还是随机读写）的差异，上面的简单解释对于实际选择没有太大帮助，实际该选择哪个基本还是要实测来验证。不过下面几条说明供参考：

NOOP全称No Operation,中文名称电梯式调度器，该算法实现了最简单的FIFO队列，所有I/O请求大致按照先来后到的顺序进行操作。NOOP实现了一个简单的FIFO队列,它像电梯的工作方式一样对I/O请求进行组织。它是基于先入先出（FIFO）队列概念的 Linux 内核里最简单的I/O 调度器。此调度程序最适合于固态硬盘。

Deadline翻译成中文是截止时间调度器，是对Linus Elevator的一种改进，它避免有些请求太长时间不能被处理。另外可以区分对待读操作和写操作。DEADLINE额外分别为读I/O和写I/O提供了FIFO队列。

Deadline对读写request进行了分类管理，并且在调度处理的过程中读请求具有较高优先级。这主要是因为读请求往往是同步操作，对延迟时间比较敏感，而写操作往往是异步操作，可以尽可能的将相邻访问地址的请求进行合并，但是，合并的效率越高，延迟时间会越长。因此，为了区别对待读写请求类型，deadline采用两条链表对读写请求进行分类管理。但是，引入分类管理之后，在读优先的情况下，写请求如果长时间得到不到调度，会出现饿死的情况，因此，deadline算法考虑了写饿死的情况，从而保证在读优先调度的情况下，写请求不会被饿死。

总体来讲，deadline算法对request进行了优先权控制调度，主要表现在如下几个方面：

CFQ全称Completely Fair Scheler ，中文名称完全公平调度器，它是现在许多 Linux 发行版的默认调度器，CFQ是内核默认选择的I/O调度器。它将由进程提交的同步请求放到多个进程队列中，然后为每个队列分配时间片以访问磁盘。 对于通用的服务器是最好的选择，CFQ均匀地分布对I/O带宽的访问 。CFQ为每个进程和线程，单独创建一个队列来管理该进程所产生的请求,以此来保证每个进程都能被很好的分配到I/O带宽，I/O调度器每次执行一个进程的4次请求。该算法的特点是按照I/O请求的地址进行排序，而不是按照先来后到的顺序来进行响应。简单来说就是给所有同步进程分配时间片，然后才排队访问磁盘。

多队列无操作I / O调度程序。不对请求进行重新排序，最小的开销。NVME等快速随机I / O设备的理想选择。

这是对最后期限I / O调度程序的改编，但设计用于 多队列设备。一个出色的多面手，CPU开销相当低。

‘伍’ linux进程、线程及调度算法（二）

执行一个 ，但是只要任何修改，都造成分裂如，修改了chroot,写memory，mmap，sigaction 等。

p1 是一个 task_struct, p2 也是一个 task_struct. linux内核的调度器只认得task_struck （不管你是进程还是线程）, 对其进行调度。
p2 的task_struck 被创建出来后，也有一份自己的资源。但是这些资源会短暂的与p1 相同。
进程是区分资源的单位，你的资源是我的资源，那从概念上将就不叫进程。

其他资源都好分配，唯一比较难的是内存资源的重新分配。

非常简单的程序，但是可以充分说明 COW。
结果：10 -> 20 -> 10

COW 是严重依赖于CPU中的MMU。CPU如果没有 MMU,fork 是不能工作的。
在没有mmu的CPU中，不可能执行COW 的，所以只有vfork
vfork与fork相比的不同

P2没有自己的 task_struct, 也就是说P1 的内存资源 就是 P2的内存资源。

结果 10,20,20

vfork：

vfork 执行上述流程，P2也只是指向了P1的mm，那么将这个vfork 放大，其余的也全部clone，共同指向P1，那么就是线程的属性了。
phtread_create -> Clone()

P1 P2 在内核中都是 task_struct. 都可以被调度。共享资源可调度，即线程。 这就是线程为什么也叫做轻量级进程
不需要太纠结线程和进程的区别。

4651 ： TGID
4652, 4653 tid 内核中 task_struct 真正的pid

linux 总是白发人 送 黑发人。如果父进程在子进程推出前挂掉了。那么子进程应该怎么办？

p3 -> init， p5 -> subreaper

每一个孤儿都会找最近的火葬场
可以设置进程的属性，将其变为subreaper，会像1号进程那样收养孤儿进程。

linux的进程睡眠依靠等待队列，这样的机制类似与涉及模式中的订阅与发布。
睡眠，分两种

每一个进程都是创建出来的，那么第一个进程是谁创建的呢？
init 进程是被linux的 0 进程 创建出来的。开机创建。

父进程就是 0 号进程，但在pstree，是看不到0进程的。因为0进程创建子进程后，就退化成了idle进程。
idle进程是 linux内核里，特殊调度类。 所有进程都睡眠停止 ，则调度idle进程，进入到 wait for interrupte 等中断。此时 cpu及其省电，除非来一个中断，才能再次被唤醒。
唤醒后的任何进程，从调度的角度上说，都比idle进程地位高。idle是调度级别最最低的进程。
0 进程 一跑，则进入等中断。一旦其他进程被唤醒，就轮不到 0进程了。
所有进程都睡了，0就上来，则cpu需要进入省电模式

‘陆’ linux 下 进程和线程的区别

线程是指进程内的一个执行单元,也是进程内的可调度实体.
与进程的区别:
(1)地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间;
(2)资源拥有:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源
(3)线程是处理器调度的基本单位,但进程不是.
4)二者均可并发执行.
进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程是系统进行资源分配和调度的一个独立单位。线程是进程的一个实体，是CPU调度和分派的基本单位，线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器，一组寄存器和栈），但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。

2.进程和应用程序的区别？

进程与应用程序的区别在于应用程序作为一个静态文件存储在计算机系统的硬盘等存储空间中，而进程则是处于动态条件下由操作系统维护的系统资源管理实体。
C、C++、Java等语言编写的源程序经相应的编译器编译成可执行文件后，提交给计算机处理器运行。这时，处在可执行状态中的应用程序称为进程。从用户角度来看，进程是应用程序的一个执行过程。从操作系统核心角度来看，进程代表的是操作系统分配的内存、CPU时间片等资源的基本单位，是为正在运行的程序提供的运行环境。进程与应用程序的区别在于应用程序作为一个静态文件存储在计算机系统的硬盘等存储空间中，而进程则是处于动态条件下由操作系统维护的系统资源管理实体。多任务环境下应用程序进程的主要特点包括： ●进程在执行过程中有内存单元的初始入口点，并且进程存活过程中始终拥有独立的内存地址空间； ●进程的生存期状态包括创建、就绪、运行、阻塞和死亡等类型； ●从应用程序进程在执行过程中向CPU发出的运行指令形式不同，可以将进程的状态分为用户态和核心态。处于用户态下的进程执行的是应用程序指令、处于核心态下的应用程序进程执行的是操作系统指令

3.进程与Java线程的区别

应用程序在执行过程中存在一个内存空间的初始入口点地址、一个程序执行过程中的代码执行序列以及用于标识进程结束的内存出口点地址，在进程执行过程中的每一时间点均有唯一的处理器指令与内存单元地址相对应。
Java语言中定义的线程（Thread）同样包括一个内存入口点地址、一个出口点地址以及能够顺序执行的代码序列。但是进程与线程的重要区别在于线程不能够单独执行，它必须运行在处于活动状态的应用程序进程中，因此可以定义线程是程序内部的具有并发性的顺序代码流。 Unix操作系统和Microsoft Windows操作系统支持多用户、多进程的并发执行，而Java语言支持应用程序进程内部的多个执行线程的并发执行。多线程的意义在于一个应用程序的多个逻辑单元可以并发地执行。但是多线程并不意味着多个用户进程在执行，操作系统也不把每个线程作为独立的进程来分配独立的系统资源。进程可以创建其子进程，子进程与父进程拥有不同的可执行代码和数据内存空间。而在用于代表应用程序的进程中多个线程共享数据内存空间，但保持每个线程拥有独立的执行堆栈和程序执行上下文（Context）。
需要注意的是：在应用程序中使用多线程不会增加 CPU 的数据处理能力。只有在多CPU 的计算机或者在网络计算体系结构下，将Java程序划分为多个并发执行线程后，同时启动多个线程运行，使不同的线程运行在基于不同处理器的Java虚拟机中，才能提高应用程序的执行效率。 另外，如果应用程序必须等待网络连接或数据库连接等数据吞吐速度相对较慢的资源时，多线程应用程序是非常有利的。基于Internet的应用程序有必要是多线程类型的，例如，当开发要支持大量客户机的服务器端应用程序时，可以将应用程序创建成多线程形式来响应客户端的连接请求，使每个连接用户独占一个客户端连接线程。这样，用户感觉服务器只为连接用户自己服务，从而缩短了服务器的客户端响应时间。 三、Java语言的多线程程序设计方法

‘柒’ 如何查看linux线程的调度策略

方法一：PS
在ps命令中，“-T”选项可以开启线程查看。下面的命令列出碰态了由进程号为<棚带pid>的进程链吵芦创建的所有线程。
1.$ ps -T -p <pid>

“SID”栏表示线程ID，而“CMD”栏则显示了线程名称。

方法二： Top
top命令可以实时显示各个线程情况。要在top输出中开启线程查看，请调用top命令的“-H”选项，该选项会列出所有Linux线程。在top运行时，你也可以通过按“H”键将线程查看模式切换为开或关。
1.$ top -H

要让top输出某个特定进程<pid>并检查该进程内运行的线程状况：
$ top -H -p <pid>

‘捌’ linux调度是基于进程还是线程

在LINUX系统之中，被调度的应该是进程。因为只有进程才拥有一个独立的上下文环境，是分配系统资源的最小单位……而线程在SMP体系中加速了执行的效率……
在LINUX之中，线程也可称作轻量级进程，它能享有自己的堆栈，线程ID等独立资源，但大多还是要依赖其创建进程，比如地址空间，信号，文件句柄……

‘玖’ Linux进程与线程的区别和联系

进程中可包含多个线程，最少1个，进程可控制进程内线程的运行暂停及结束，线程可共享进程全局变量，进程与进程是单独个体，相互不能直接访问各自线程及全局变量

‘拾’ linux进程、线程及调度算法（三）

调度策略值得是大家都在ready时，并且CPU已经被调度时，决定谁来运行，谁来被调度。

两者之间有一定矛盾。
响应的优化，意味着高优先级会抢占优先级，会花时间在上下文切换，会影响吞吐。
上下文切换的时间是很短的，几微妙就能搞定。上下文切换本身对吞吐并多大影响， 重要的是，切换后引起的cpu 的 cache miss.
每次切换APP, 数据都要重新load一次。
Linux 会尽可能的在响应与吞吐之间寻找平衡。比如在编译linux的时候，会让你选择 kernal features -> Preemption model.
抢占模型会影响linux的调度算法。

所以 ARM 的架构都是big+LITTLE， 一个很猛CPU+ 多个 性能较差的 CPU, 那么可以把I/O型任务的调度 放在 LITTLE CPU上。需要计算的放在big上。

早期2.6 内核将优先级划分了 0-139 bit的优先级。数值越低，优先级越高。0-99优先级 都是 RT（即时响应）的 ，100-139都是非RT的，即normal。
调度的时候 看哪个bitmap 中的 优先级上有任务ready。可能多个任务哦。

在普通优先级线程调度中，高优先级并不代表对低优先级的绝对优势。会在不同优先级进行轮转。
100 就是比101高，101也会比102高，但100 不会堵着101。
众屌丝进程在轮转时，优先级高的：

初始设置nice值为0，linux 会探测 你是喜欢睡眠，还是干活。越喜欢睡，linux 越奖励你，优先级上升（nice值减少）。越喜欢干活，优先级下降（nice值增加）。所以一个进程在linux中，干着干着 优先级越低，睡着睡着 优先级越高。

后期linux补丁中

红黑树，数据结构， 左边节点小于右边节点
同时兼顾了 CPU/IO 和 nice。
数值代表着 进程运行到目前为止的virtual runtime 时间。

（pyhsical runtime） / weight * 1024(系数)。
优先调度 节点值（vruntime）最小的线程。权重weight 其实有nice 来控制。

一个线程一旦被调度到，则物理运行时间增加，vruntime增加，往左边走。
weight的增加，也导致vruntime减小，往右边走。
总之 CFS让线程 从左滚到右，从右滚到左。即照顾了I/O(喜欢睡，分子小) 也 照顾了 nice值低（分母高）.所以 由喜欢睡，nice值又低的线程，最容易被调度到。
自动调整，无需向nice一样做出奖励惩罚动作，个人理解权重其实相当于nice

但是 此时 来一个 0-99的线程，进行RT调度，都可以瞬间秒杀你！因为人家不是普通的，是RT的!

一个多线程的进程中，每个线程的调度的策略 如 fifo rr normal, 都可以不同。每一个的优先级都可以不一样。
实验举例, 创建2个线程，同时开2个：

运行2次，创建两个进程
sudo renice -n -5(nice -5级别) -g(global)， 会明显看到 一个进程的CPU占用率是另一个的 3倍。

为什么cpu都已经达到200%，为什么系统不觉得卡呢？因为，我们的线程在未设置优先级时，是normal调度模式，且是 CPU消耗型 调度级别其实不高。

利用chrt工具，可以将进程 调整为 50 从normal的调度策略 升为RT （fifo）级别的调度策略，会出现：

chrt , nice renice 的调度策略 都是以线程为单位的，以上 设置的将进程下的所有线程进行设置nice值
线程是调度单位，进程不是，进程是资源封装单位！

两个同样死循环的normal优先级线程，其中一个nice值降低，该线程的CPU 利用率就会比另一个CPU的利用率高。