Linux 内核的操作系统是不是得一直运行着_-高鹏

当年上我老板的OS课，老板上来就告诉我们，OS不是运行着的代码，而是一堆躺在内存里等着被调用的代码。

内核就是一个由interrupt驱动的程序。这个interrupt可以是一个系统调用（x86下，很多OS的系统调用是靠software interrupt实现的），可以是一个用户程序产生的异常，也可以是一个硬件产生的事件中断。

于是你的问题解决了：一个用户程序运行的时候，Linux就在内存里呆着，等着一个中断的到来。在这个中断的处理过程中，来做“调度”。而一般的时分系统里，都会有个timer interrupt每隔一段时间到来，也就是楼上说的“时间片”。

PS：很多人在认识OS的过程中被大量的artificial concept给困惑了。比如神马进程，线程，调度，micro kernel，monolithic kernel的。从x86架构上来理解OS才是王道。

=================================================================

PS of PS: 把评论粘上来，补充上面的PS，谢

@许越

提醒：

因为很多教材在讲os的时候，更喜欢从app的角度来看待os，于是很多时候被各种概念绑架。因为很多例如进城，线程，系统调用这样的东西都是由os在硬件上抽象出来的。站在这些概念上看os，就有点“不识庐山真面目”的感觉。所以我的意思是从硬件的角度看os，反过来理解为何os要抽象出这些概念。站在cpu的角度，理解指令是怎么在cpu上一条一条的运行的。

评论区

且听风雨: 一句话 中断才是系统运行的动力 👍🏽617 💭N/A IP 🕐2015-01-04 12:18:53

│ └── flytosky: [赞同]牛 这个时候 才能感叹知乎的伟大 👍🏽16 💭N/A IP 🕐2024-06-26 23:31:51
│ └── song1118公平评测: 我感觉当初翻译不太好，应该翻译为改革----没有改革就会一潭死水，死神永生的系统毫无意义。 👍🏽6 💭N/A IP 🕐2024-09-07 18:29:56
│ │ └── 飞鱼: 那书就没了 👍🏽2 💭N/A IP 🕐2024-12-02 19:38:45
│ │ └── 时间差不多喽: 该感觉你是在找茶喝啊[尴尬] 👍🏽0 💭N/A IP 🕐2024-12-19 10:28:52
│ └── hunt978: 还有死循环哦 👍🏽0 💭N/A IP 🕐2024-09-10 21:58:19
│ └── 何以为家: 更精确来说应该是trap 👍🏽0 💭N/A IP 🕐2024-12-03 01:45:10
│ └── 廾匸: 所以cpu的主频越高，执行中断越快，性能就越好，是这样吗？ 👍🏽0 💭N/A IP 🕐2025-04-22 12:58:01
│ └── 得闲饮茶dd: 不只是执行中断越快。主频越高，同一时间能执行的指令越多，计算速度就越快。但主频并非唯一决定性能的指标。还有核心架构，架构越先进，同主频下性能越好，换一种说法就是IPC高 👍🏽0 💭N/A IP 🕐2025-05-14 04:12:00

知乎用户cG36YY: OS就是一个大的中断处理handler，scheduler被时钟（825x芯片驱动）定期唤醒选一个喜欢的process去run 👍🏽245 💭N/A IP 🕐2017-01-22 09:08:15

Arcueid Brunestud: 花了好久才理解到这点。中断驱动其实才是核心概念。 👍🏽76 💭N/A IP 🕐2015-05-26 10:53:03

力量举李泽汝: 看了答主的回答有点相见恨晚的感觉，确实在学习OS和内核的时候一直都有迷惑，被抽象的概念给带进坑里了，突然一回首就发现什么都接不上了，看来是应该从CPU是如何执行指令的角度去分析和学习。 👍🏽43 💭N/A IP 🕐2015-10-01 22:53:16

│ └── 知乎用户q989ZT: 这个说法只能用来理解OS的进程、外设部分吧[捂脸]对于文件系统、网络协议，这个说法基本上毫无帮助 👍🏽9 💭N/A IP 🕐2024-06-20 15:22:53

Wu23333: “内核是一堆等着被调用的代码”对于现代操作系统已经不完全对了，Linux会有很多内核线程在主动的运行（从宏观上也可以说是“持续运行”）。出于优化性能的目的，大量实际的操作也是在内核线程中完成的，比如用户程序对于磁盘上一个文件调用write()，因为有缓冲机制，实际完成磁盘写入的并不是在write系统调用过程中，而是在Linux的pdflush内核线程 👍🏽34 💭N/A IP 🕐2022-05-08 04:24:59

│ └── 筆墨凪彦: 如果是微观方面的话，还是处在调度器的管辖之下，调度器如何调度任务则基本上还是和答主说的类似 👍🏽3 💭N/A IP 🕐2023-03-31 19:21:21
│ │ └── wjr: 然而，Linux内核又不止是一个调度器调度器只是模块之一而已 👍🏽1 💭N/A IP 🕐2023-11-26 12:39:20
│ └── 季梁止: 运行总是有个起点，只是太多运行起了当不再需要时仍不关的流氓程序 👍🏽0 💭N/A IP 🕐2023-07-15 09:27:23
│ └── 迷样小z: 你就是作者所说的从软件看系统的人 👍🏽44 💭N/A IP 🕐2023-10-20 08:03:45
│ │ └── Rommel: 未尝不可 👍🏽0 💭N/A IP 🕐2024-06-27 11:40:29
│ └── Hi jack: 你说的这部分不应该划分到答主内核的概念，他指的是纯粹的任务调度。照你这么说，各种io接口的缓冲机制都得来一遍，本质上那都是app 👍🏽21 💭N/A IP 🕐2023-12-04 20:43:27
│ │ └── zzzzhy: 答主老师的认知确实是过时了[捂脸]。OS显然是要从多个角度来认识的，光从硬件角度看就OK了么？显然不是。 👍🏽2 💭N/A IP 🕐2024-12-30 16:08:41
│ └── 爱学习: 任务调度，也是中断服务程序发起的。 👍🏽1 💭N/A IP 🕐2024-02-16 13:58:29
│ └── Wu23333: 统一回复：我这里指的内核当然是指所有运行在内核态的代码，linux这种内核线程当然算内核的一部分。如果你的定义不同，那讨论也没啥意义，就不再回复了。当然你要说”内核线程也是被调度器调用的，调度器也是被中断调用的“话，那任何东西都是等着被调用的，这正确但也没啥意义，就不一一回复了。 👍🏽3 💭N/A IP 🕐2024-02-20 17:20:32
│ └── 岁月涟漪: 终于说到我心里了[大笑] 👍🏽0 💭N/A IP 🕐2024-04-02 12:14:31
│ └── 蜘蛛侠: 你理解的还不够本质，在最最底层，线程没有主动运行的能力，代码运行都是被动的。 👍🏽1 💭N/A IP 🕐2024-12-27 11:41:00
│ │ └── Wu23333: 见楼上 👍🏽0 💭N/A IP 🕐2024-12-27 13:14:01
│ │ └── 蜘蛛侠: 我看了，你还是以软件层面去思考这个问题，还不够本质。 👍🏽0 💭N/A IP 🕐2024-12-27 14:44:33
│ │ └── Wu23333: 整天本质本质的，实际是种缺乏从系统角度思考时的偷懒想法。照你们这么说，任何代码都是等着被调用的，这就跟“任何指令都是cpu时钟驱动的”，一样，是句正确的废话，对你去理解unix和dos有什么不同没有任何帮助 👍🏽6 💭N/A IP 🕐2024-12-27 15:14:26
│ └── 匿名会员: 内核线程怎么主动运行？靠的就是时钟中断。 👍🏽0 💭N/A IP 🕐2025-05-11 15:39:33

灵狐: 我们有句话是这么说的：从CPU架构，看到的是真相。从APP角度，看到的是抽象。 👍🏽22 💭N/A IP 🕐2024-06-07 17:53:24

cellphone峰: 看到第一句话我就点赞了 👍🏽18 💭N/A IP 🕐2020-12-25 16:28:35

│ └── 灵狐: 真正懂操作系统人，看第一句话就懂了。 👍🏽5 💭N/A IP 🕐2024-06-07 18:00:51
│ └── Rommel: 说明你是系统领域大佬👍 👍🏽1 💭N/A IP 🕐2024-06-27 11:41:03

御宅暴君: 当然，动手实现微型操作系统也不失为一种好办法。网上有很多现成的 Step by Step 教程，知乎就有各种各样的推荐：写一个操作系统内核有多难？大概的内容、步骤是什么？ 计算机怎样自己写一个简单的操作系统？ 系统架构如何从零开始写一个简单的操作系统？ - 学习 👍🏽15 💭N/A IP 🕐2015-01-02 23:51:25

abadcafe: kernel里边也有内核线程在不停地跑着的. 👍🏽9 💭N/A IP 🕐2015-01-04 14:30:57

│ └── 高鹏: 你确定是一直跑着？ 👍🏽2 💭N/A IP 🕐2015-05-22 04:58:16
│ │ └── abadcafe: 看你从哪个角度看. 如果你从分时复用的角度来看, 单CPU系统上, 同一时刻一定只有一个routine在跑, 要不就是一个进程, 要不就是一个中断处理程序. 这样除非你把中断处理程序写成死循环, 否则任何东西你都不能说成是"一直跑着".但如果从宏观的角度看, 哪怕是老版本的linux kernel基本没有内核线程在跑, 你也必须注意, 中断处理程序是一个跟你的进程并行执行的routine, 而只要你的系统在run, 那就一定有各种中断. 再来, 现在kernel里边各子系统都有一堆内核线程在跑. 你PS看一眼, 那些进程名带[]的就是了, 这些大部分是从开机就创建一直要跑到关机. 👍🏽29 💭N/A IP 🕐2015-05-22 05:08:43
│ │ │ └── 苏卡卡: 我不明白你为什么要从分时复用的角度看. 我也不明白你为什么从宏观的角度看.而且感觉你看的很乱.我认为应该从一个cpu时钟周期看. 很明显 ,有时候 cpu 时钟周期 在做你的 app ,app 不属于 操作 系统,那么 操作系统就不是一直在运行,你说的 死循环也不是一直在跑着,你说的 带 [ ] 的 内核线程 也不是在跑着.并不是 怼你, 我看你的评论看了三十分钟,没看出来逻辑 👍🏽2 💭N/A IP 🕐2018-03-03 15:17:00
│ │ │ │ └── abadcafe: 你还没到时候，先看看书吧，有些知识点你还没学到 👍🏽0 💭N/A IP 🕐2018-03-03 15:59:37
│ │ │ │ └── 苏卡卡: 你可以给我推荐一些书吗?谢谢!另外,你可以说一下我对你的评论哪里有问题吗? 👍🏽0 💭N/A IP 🕐2018-03-03 16:35:00
│ │ │ │ └── abadcafe: 基本上你还没入门, CPU/OS的书你都需要看. 可能对你而言see mips run还不错吧? 操作系统设计与实现应该也适合. 很久没关心过入门书籍了, 我记得的也就这几本. 👍🏽1 💭N/A IP 🕐2018-03-03 16:55:33
│ │ │ │ └── 苏卡卡: 另外,我的评论哪里有问题吗? 👍🏽0 💭N/A IP 🕐2018-03-03 17:01:19
│ │ │ │ └── abadcafe: 问题太多, 无从讲起. 👍🏽0 💭N/A IP 🕐2018-03-03 19:59:19
│ │ │ └── 文佳胜: 有疑问。单cpu系统中，同一时刻要么是一个应用进程在执行，要么是一个中断处理程序在执行。只有这两种吗？中断处理程序作为一段被执行的内核代码也可以看做是线程？打扰了。 👍🏽0 💭N/A IP 🕐2018-03-23 15:22:37
│ │ │ └── abadcafe: 只有这两种. 👍🏽0 💭N/A IP 🕐2018-03-23 15:47:20
│ │ │ └── Magnificent: 中断处理程序ISR不可以当做线程看待，ISR不可以睡眠的，线程可以。在ISR里面，不可以schedule（）。 👍🏽4 💭N/A IP 🕐2022-06-04 09:17:46
│ │ │ └── chris liu: 阻塞叫不叫睡眠？ISR不可以睡眠，但可以被阻塞。[大笑] 👍🏽0 💭N/A IP 🕐2024-06-25 15:05:27
│ │ │ └── zzzzhy: ISR就是线程。线程的本质和能不能睡眠毫无关系。另外，ISR处理完一个请求后，请问，它是不是睡眠了。 👍🏽1 💭N/A IP 🕐2024-12-30 16:19:27
│ │ └── chris liu: 啥叫一直跑，指令执行流阻塞了，但没被切走，叫不叫「一直跑」[大笑] 👍🏽0 💭N/A IP 🕐2024-06-25 15:04:39
│ └── MoMo: 内核线程不是一直跑的。干完活就交出CPU了。如果内核自己的事干完了，也没有进程需要调度，就用一条特殊指令将CPU挂起，置为闲置状态，直到下一次中断唤醒才又运行。 👍🏽3 💭N/A IP 🕐2023-07-15 12:12:38
│ └── 匿名会员: cpu只有一个的单核系统，它怎么不停的跑呢？ 👍🏽0 💭N/A IP 🕐2025-05-11 15:40:50

云台自矫: 软件层面，皆为抽象 👍🏽8 💭N/A IP 🕐2017-02-28 23:40:27

龙瑜: “x86架构上来理解OS才是王道”，首先声明我极不赞成这句话！！ 按照楼说的那么如果没有用户进程在运行，内核又只当有事件发生时才运行，那么是不是CPU该停掉了？？？ 可以去看看进程号为 0 的内核任务！！这个任务就是为了确保CPU一直处于运行状态而创建的！！！ 👍🏽8 💭N/A IP 🕐2017-01-01 07:25:00

│ └── 高鹏: 呵呵 👍🏽12 💭N/A IP 🕐2017-01-01 07:38:57
│ └── 苏卡卡: 答主把所有的进程(包括PID 0 的进程)归结为 linux内核外了. 不知道 是不是就是微内核的要求. 但 我是赞成的. 👍🏽0 💭N/A IP 🕐2018-03-03 17:26:28
│ └── 王于舟: 真的没有任何任务可以加一个任务循环hlt啊 👍🏽0 💭N/A IP 🕐2022-02-17 14:01:01
│ └── 郁郁悠然: 在docker里运行的系统，用户输入一个命令，OS就执行这个命令，当这个命令执行完毕，docker就停止运行，确实可以理解为，CPU停掉了 👍🏽7 💭N/A IP 🕐2022-05-03 12:55:38
│ └── 叶芝秋: CPU不是停掉了，而是在等待中断事件来触发 👍🏽4 💭N/A IP 🕐2023-01-08 00:26:00
│ │ └── 聆听物语: 所以不是一直要有个守护进程一直放在内存中让CPU多次读取信号吗？ 👍🏽0 💭N/A IP 🕐2024-09-19 23:10:57
│ └── Turnin: 我的理解，程序是一直运行的，事件发生相当于外部中断/定时器中断，中断结束后程序仍在运行 👍🏽0 💭N/A IP 🕐2024-05-21 17:28:17

fisheuler: 我也是最近慢慢理解这些概念了，比如线程，进程，协程这些概念，都是抽象出来的概念。从硬件上说，本质上就是遵循冯诺伊曼结构体系，CPU来一条条执行指令，突然就豁然开朗了。然后就觉得，有些东西用线程来处理确实不合适。换句话说，就是没有银弹。有些场景用基于事件机制来处理更合适。 👍🏽6 💭N/A IP 🕐2015-06-14 12:57:12

abadcafe: 另外, 中断处理程序也可以看作是一个线程. 👍🏽6 💭N/A IP 🕐2015-01-04 14:31:56

│ └── 可可可: 反对 👍🏽10 💭N/A IP 🕐2022-05-23 19:51:37
│ └── 特立独行的猫: 中断处理过程运行在任意线程上下午，请先理解清楚线程是什么 👍🏽0 💭N/A IP 🕐2023-07-23 18:23:32
│ └── 宇智波欢: 中断处理程序不能被看成线程，因为它无法被调度，只有在那种被更高优先级的中断打断 👍🏽2 💭N/A IP 🕐2023-11-04 14:46:08
│ └── zzzzhy: 是的，中断处理程序实质就是一个线程。这个有着线程实质的东西，出现得远早于“线程”这个概念本身。 👍🏽0 💭N/A IP 🕐2025-06-10 13:08:55

aslaka: 中断+时钟信号，这也是为啥主频是一个很重要的参数 👍🏽5 💭N/A IP 🕐2022-05-12 09:26:03

氧化性百万酸面包: 是这样的, 操作系统虽然是程序但是更像是硬件, cpu向os提供机制, os最终完成功能的实现, 和cpu配合实现向软件提供运行环境的任务 👍🏽3 💭N/A IP 🕐2023-01-02 21:25:52

阿姨: 您的答案解决了我在学习《操作系统》中的困惑!感谢！ 👍🏽4 💭N/A IP 🕐2015-01-01 20:08:20

郝显扬: 哎，遇到这么个能深入浅出的好老板真幸运。 👍🏽3 💭N/A IP 🕐2015-01-04 14:41:12

慕容渊: 嗯，讲得挺好。有一个名词叫做“内核控制路径”。其实内核控制路径也就那么几条，能数出来。 👍🏽2 💭N/A IP 🕐2016-04-18 01:52:48

│ └── 怪火: ulk里面的Kernel control path 👍🏽0 💭N/A IP 🕐2024-04-18 12:11:54

知乎用户AYdSyg: 写的好，角度决定你看到东西。 👍🏽2 💭N/A IP 🕐2015-01-04 16:31:59

gentoofly: OS不是运行着的代码 更准确来说应该是操作系统内核 👍🏽2 💭N/A IP 🕐2016-12-16 21:28:59

mci: 顶级回答，透露了操作系统的本质 👍🏽2 💭N/A IP 🕐2024-05-20 01:22:22

可可可: 我觉得51汇编-51单片机后再学习C语言，同时学习一个简单的调度器之后学习简单RTOS，再学习操作系统是比较科学的方法。我们当年完全反过来 👍🏽1 💭N/A IP 🕐2024-02-13 14:02:20

迷路的鹿: 确实，我自己写过一个简单的内核，完成初始化和对硬件的抽象操作后就是拉起应用了，然后每次时钟中断切换线程。每个线程的页表都包含了指向内核的部分，如果软件需要调用api，该线程再主动进入内核态调用内核代码处理，内核本身没有其它要做的工作所以一般就留下了一个什么都不做的线程备用 👍🏽1 💭N/A IP 🕐2024-12-09 01:04:33

taozhu: 这个角度挺好的，就是对有底层背景的同学很好理解，估计对于写应用程序的同学有点吃力。 👍🏽1 💭N/A IP 🕐2022-05-05 15:06:35

│ └── peterhold: 写嵌入式的表示太熟悉了 👍🏽0 💭N/A IP 🕐2023-09-25 15:21:05

ccAA: 答主说的“从x86架构上来理解OS”具体是什么意思？ 👍🏽1 💭N/A IP 🕐2014-05-08 08:44:12

│ └── 高鹏: 因为很多教材在讲os的时候，更喜欢从app的角度来看待os，于是很多时候被各种概念绑架。因为很多例如进城，线程，系统调用这样的东西都是由os在硬件上抽象出来的。站在这些概念上看os，就有点“不识庐山真面目”的感觉。所以我的意思是从硬件的角度看os，反过来理解为何os要抽象出这些概念。站在cpu的角度，理解指令是怎么在cpu上一条一条的运行的。 👍🏽10 💭N/A IP 🕐2014-05-08 08:55:06
│ │ └── 青鹿: 那能否推荐本书呢？谢谢。 👍🏽1 💭N/A IP 🕐2014-05-08 08:58:41
│ │ │ └── 高鹏: 额，难住我了。我能说的就是看intel的manual，vol 3就够。另外MIT的6.828的lab很好。 👍🏽7 💭N/A IP 🕐2014-05-08 09:05:23
│ │ │ │ └── 青鹿: 好吧，别人也这样说。 👍🏽0 💭N/A IP 🕐2014-05-08 09:06:19
│ │ │ │ └── 高鹏: 我也觉着这么说非常不靠谱。不过我的确没见过这么一本书。不知道为什么。 👍🏽0 💭N/A IP 🕐2014-05-08 09:08:32
│ │ │ └── 加菲猫: 可以看freertos的手册，移植，相关源码，尤其是任务切换那里，另外要理解组成原理，和C语言运行时环境。 👍🏽2 💭N/A IP 🕐2014-05-08 18:36:47
│ │ └── 许越: 差评论补充到答案就更赞了！从不同角度理解出不同的东西，别被os抽象出来的高大上给迷惑。 👍🏽1 💭N/A IP 🕐2014-05-08 10:35:32
│ │ │ └── 高鹏: 谢提醒哈，更新了。 👍🏽1 💭N/A IP 🕐2014-05-08 11:04:09
│ │ │ └── 江湖夜雨: 对此也一直有不解。站在CPU的角度看，它根本不知道自己的在干嘛，只是突然一个信号过来了并给它一个存指令的地址，然后CPU就去该地址取指令执行。那么谁给CPU这个信号呢？这个存指令的地址是谁在哪什么时候计算出来的呢？站在操作系统的角度看，情况是不是CPU在执行PID=10090的用户进程，然后时间片到了或者有中断发生，此时CPU的下一条指令地址变成调度进程入口，由用户态切换成内核态，执行调度任务，调度任务算出下一个进程应该是PID=10095，那么再从调度进程切换到PID=10095，也即进程切换并不是从PID=10090直接切换成PID=10095，而是每次进程切换之间都会有调度进程的运行，10090，调度进程，10095。 👍🏽2 💭N/A IP 🕐2018-06-21 23:26:42
│ │ │ └── nopark: 我猜这个PID恐怕也是不存在的。我以单片机的视角想象一下，那么你说的对，CPU是根本不知道自己在干什么，如果不是一开始主板的引导程序引导它到硬盘去读取代码，那么他都不知道接下来要干什么。一开始到硬盘去读取的就是所谓的操作系统的代码，读取完这些代码后，这些代码就被执行了，这些代码先是初始化，比如注册了针对各种中断的回调响应逻辑，比如代码执行不下去的时候要如何回调让程序崩溃的处理。再设定一个时钟中断，比如说一毫秒，并注册上回调响应逻辑来实现时间片的切换。又比如创建内存的管理结构，方便给操作系统下的程序分配内存。当然操作系统还提供一些等待被主动调用的接口函数，例如开一个程序，也就是创建进程。这些函数都趴在固定的地址上，等着别人来用。这些都初始化完成以后，操作系统就算启动完成了。于是操作系统开始按照一个初始列表去加载程序，来实现基本功能，比如桌面，比如各种服务等等。假设到这里用户不再进行操作，那么我们就会看到操作系统执行的最频繁的代码就是时钟中断。他没完没了的把内存中存在的几个程序切换来切换去。它会保存掉当前所执行程序的上下文。并按照一个列表恢复其他程序的上下文，然后切换过去。也就是所谓的切换时间片。用户在桌面上打开了某个程序，那么实际上是由桌面程序取命令操作系统加载一个新的程序。那个新的程序出现了断错误，导致CPU无法执行下去。于是系统就拿到了这个无法执行下去的回调，宣布这个新的程序崩溃了，弹了个窗让用户也一起崩溃。你所看到的PID其实是操作系统的逻辑代码在加载程序时给出的，由系统自己生成的一个ID。他跟CPU没啥关系，只是操作系统为了方便管理自己所开的各种程序，这里为了方便称作进程，而出现的。所以在CPU看来也根本不存在。 👍🏽0 💭N/A IP 🕐2023-11-10 09:54:30
│ │ │ └── 南宫飞燕: 写得好 👍🏽0 💭N/A IP 🕐2024-12-22 01:50:14
│ │ └── 加菲猫: 我很赞同答主观点，那时一直很迷茫 👍🏽0 💭N/A IP 🕐2014-05-08 18:35:01
│ │ └── 王超: 具体讲一下呗 👍🏽0 💭N/A IP 🕐2016-12-26 21:58:12
│ └── 可可可: 学过单片机就懂了。单片机怎么在不同的时间处理不同的任务？——中断处理。怎么中断后继续——上下文保存。一步一步各种应用程序以外的程序组成了os 👍🏽1 💭N/A IP 🕐2022-05-23 19:55:41

特立独行的猫: [赞同]很多人学习操作系统一上来久拍一堆各种 微内核宏内核系统架构、内存管理、进程线程，真是一群乌合之众，不懂cpu的体系架构学操作系统等于看天书 👍🏽1 💭N/A IP 🕐2023-07-23 18:19:42

Lin: 大爷进城玩儿呀 👍🏽1 💭N/A IP 🕐2022-09-06 20:45:45

爱吃红烧茄子: int 80[飙泪笑] 👍🏽1 💭N/A IP 🕐2022-05-06 01:43:13

小愤青: 对啊，当年上操作系统，一辈子也不知道怎么用c语言实现什么进程调度。后来自己去看了x86汇编语言，自然而然理解了怎么通过系统调用中断切换内核态，一个进程怎么被暂停换成另外一个，无非就是用户程序和内核程序交替运行，每次内核程序根据进程的描述表，然后计算出进程运行到哪儿了，把他的栈恢复而已 👍🏽125 💭N/A IP 🕐2017-08-26 12:37:30

│ └── SpicyLemon: 有什么书推荐吗 👍🏽1 💭N/A IP 🕐2022-10-07 18:40:31
│ └── 大大的橙: 玩底层，建议从单片机开始，从一个按键的输入一个发光二极管做输出开始。最后移植自己裁剪过的linux到单片机上。 👍🏽21 💭N/A IP 🕐2024-02-25 08:53:28
│ └── 明明: 玩玩单片机，看看一些开源rtos是怎么做的 👍🏽0 💭N/A IP 🕐2024-06-27 10:31:31
│ └── 游方老道: 更友好的是直接看看操作系统入门，于渊的自己动手写操作系统， 从系统引导，实模式/保护模式，中断，多进程的实现，任务调度策略，驱动和系统调用实现，都可以快速了解，性价比很高 👍🏽2 💭N/A IP 🕐2025-01-27 18:23:19

张知: 动手写个能处理中断的单片机就理解了，比如按一个按钮就会除非gpio的中断，然后程序里再判断该干嘛，就跟鼠标键盘输入是一个道理，只不过为了便于使用，就用os+驱动把这些底层硬件中断层层封装起来，暴露给app作为事件接口 👍🏽1 💭N/A IP 🕐2024-12-03 21:36:12

龙瑜: 呵呵 👍🏽1 💭N/A IP 🕐2017-01-01 07:48:29

lliad: 是这样的[大笑] 第一次学 OS 的时候，学校根据恐龙书（操作系统概念）做的 ppt，质量一坨，后面自学 xv6、rCore 才理解 👍🏽0 💭N/A IP 🕐2025-07-08 22:58:04

Jade: 我是在学freertos源码的时候搞懂这个的，对于CortexM3就是基于SVC、PendSV和Systick三种中断，底层实现需要配置相应寄存器。需要理解的是，计算机最最底层是串行的，包括并发也一样，所以你调动操作系统，同时也就只能跑操作系统的函数代码，然后才能到进程里面 👍🏽0 💭N/A IP 🕐2025-05-14 10:37:10

匿名会员: 妙啊！ 👍🏽0 💭N/A IP 🕐2025-05-11 15:37:50

皮皮龙: 操作系统就是一个由事件驱动的中断处理程序 👍🏽0 💭N/A IP 🕐2025-04-14 09:06:18

Simona: 玩嵌入式往板子上移植rtos才搞明白操作系统究竟怎么回事 👍🏽0 💭N/A IP 🕐2025-04-09 01:55:51

木佑: cpu也是电路，可以从一开始的机械计算机来理解，就是给个打孔带，摇摇摇，把输出摇出来 👍🏽0 💭N/A IP 🕐2025-04-03 10:52:29

badger: 非常好的角度。[赞] 👍🏽0 💭N/A IP 🕐2025-04-02 21:46:55

时光老了我仍等你: 这里说明一下避免误解，触发系统调用实际上是硬中断，不过因为是软件主动触发的所以叫软件中断，即software interrupt，是硬中断的一个分类，另外，软中断是指软件自己实现的模拟中断，由ksoftirqd线程进行处理的 👍🏽0 💭N/A IP 🕐2025-03-15 11:24:24

番茄酱: 这居然是十年前的回答，我20年毕业到23年慢慢才自己领悟到这个东西。要能早点看到少点疑惑 👍🏽0 💭N/A IP 🕐2025-03-03 10:30:04

Sousuke: 也不是。现在kernel有kernel thread了，可以在后面运行一些代码的。 👍🏽0 💭N/A IP 🕐2025-02-04 05:21:49

│ └── Jade: 你这个在简易OS freertos里面貌似叫空闲任务，一开始就创建，一直运行，优先级最低，但是讲到根它还是操作系统里面顺序执行的的代码而已 👍🏽0 💭N/A IP 🕐2025-05-14 10:39:39

潇汀: 系统就是一个大的while循环，用中断打断他 👍🏽0 💭N/A IP 🕐2025-01-27 12:09:04

│ └── xingren jia: 感觉不太对。以前编译内核加制作init img，引导起一个小环境，当时制作文件系统忘记了复制init.d 命令，内核跑起来也加载了文件系统，但因为没有进程可以执行，就挂在那里了。什么反应都没有。 👍🏽0 💭N/A IP 🕐2025-05-31 03:37:39
│ └── 潇汀: 那不就是死机了吗？[捂脸] 👍🏽0 💭N/A IP 🕐2025-05-31 12:04:15

听风辨雨: 第一句话就让人眼前一黑，操作系统之外有哪个程序不满足这个论断吗？说中断是操作系统的核心就好像拿着一本接口手册对人夸耀，来来来，这个项目的精华都在这里了。 👍🏽0 💭N/A IP 🕐2025-01-26 18:14:34

高博: 答主的学习方法很对，高层概念是会快速变化的，但掌握了底层概念则可以迅速理解既有高层概念甚至构建新的高层概念。 👍🏽0 💭N/A IP 🕐2025-01-26 12:23:00

啥也不是: 当年第一次看完《Linux内核剖析》，瞬间豁然开朗。OS是一堆代码片段，被各种中断驱动（跳转、加载），根本不是以前学的那种main进去捋出一条（或几条）逻辑线。思维方式完全不一样[捂嘴]然后就对能设计OS的人膜拜。然后现在遇到协程，总是受OS设计思路影响，玩的很嗨[捂嘴] 👍🏽0 💭N/A IP 🕐2025-01-25 14:33:10

七零八落: 简单来说就是死循环和事件驱动，一切皆是如此[捂脸] 👍🏽0 💭N/A IP 🕐2025-01-21 17:33:52

│ └── 啥也不是: 还不是无限循环。OS可以没有循环，一辈子条件判断跳跳跳。受此启发，我现在写协程也不写循环，协程函数结束前再创一个自己就好[捂嘴] 👍🏽0 💭N/A IP 🕐2025-01-25 14:36:52

骚大喵: 一句话就给我看懂了 👍🏽0 💭N/A IP 🕐2025-01-20 16:59:20

momo: 写过复杂单片机程序的人，理解 OS 的本质就很容易。最开始是一个主函数，然后写一个死循环，等待中断触发执行任务，任务多了就要分发，时间片轮转，各种状态机，于是一个很简单的进程模型就出现了。 👍🏽0 💭N/A IP 🕐2025-01-07 12:53:24

│ └── 啥也不是: 再激进一点。不要死循环，只要设计好状态机就行，条件判断跳跳跳。 👍🏽0 💭N/A IP 🕐2025-01-25 14:38:40

蜀南佳人陈巨丑: 系统时钟，赫兹，电信号。 👍🏽0 💭N/A IP 🕐2024-12-24 10:18:13

怪火: 我的妈呀，终于找回来这个帖子了。以前就看过，一直记得因为这个帖子跟我的想法很相似。 👍🏽0 💭N/A IP 🕐2024-12-07 01:31:11

额额额: 确实，操作系统的核心之一是中断。 👍🏽0 💭N/A IP 🕐2024-12-02 09:13:18

额额额: 问下楼主，进程切换的整个过程都是属于中断处理吗， 👍🏽0 💭N/A IP 🕐2024-12-02 09:12:00

電子火鸡: 醍醐灌顶[赞同] 👍🏽0 💭N/A IP 🕐2024-09-14 12:55:40

转弯踩屎007: 这个问题建议去做一做的南京大学的PA实验，会有很深刻的理解 👍🏽0 💭N/A IP 🕐2024-09-08 00:46:25

Keyboard Hero: 跳过了外部读到内部这一段，省略了内存到缓存这一段 👍🏽0 💭N/A IP 🕐2024-08-08 11:45:49

Sakura Wong: 初学操作系统实际上可以从dos入手，先了解冷加载、bios引导，再到io.sys、config.sys这几个加载过程 👍🏽0 💭N/A IP 🕐2024-07-30 23:18:18

再见路飞: 大道至简[爱][爱] 👍🏽0 💭N/A IP 🕐2024-07-26 11:08:18

孙延伟: [赞同] 👍🏽0 💭N/A IP 🕐2024-06-19 22:38:03

Turnin: 感觉实际上还是单片机定时器中断哈哈哈 👍🏽0 💭N/A IP 🕐2024-05-21 17:26:50

Oliver: kthread呢？ 👍🏽0 💭N/A IP 🕐2024-05-21 19:05:31

哈哈镜: 确实，一直以为os跟app一样不断运行，但是一想也不知道在运行什么，在看了闪客的linux源码趣读后给了我一种新的解释，os就是中断的组合 👍🏽0 💭N/A IP 🕐2024-05-21 15:57:41

克罗迪尔: 每次我自己快要解决迷惑了才有人来给我指点迷津[捂脸]。是因为以前根基太浅大佬们说了我也看不懂吗[捂脸]。感谢大佬[拜托] 👍🏽0 💭N/A IP 🕐2024-05-20 10:20:39

书画策划人鲁宾: 学习了。 👍🏽0 💭N/A IP 🕐2024-05-03 14:22:56

小肥羊: 恍然大悟 👍🏽0 💭N/A IP 🕐2024-04-21 09:48:07

怪火: 我就是这样理解的，本质上是面对向量表编程 👍🏽0 💭N/A IP 🕐2024-04-18 12:10:40

小男企鹅: 从硬件的角度看，OS的怎么运行在多个CPU核心上的呢？ 👍🏽0 💭N/A IP 🕐2024-04-15 09:32:37

光辉之路: operating system as an extended machine;it’s as a resource manager.Tanenbaum说的已经很清楚了。kernel里的汇编代码是干嘛用的？是为了炫技还是干别的事？想明白这点，也就解惑了 👍🏽0 💭N/A IP 🕐2024-03-29 14:17:06

│ └── 怪火: 出自哪里，想看看 👍🏽0 💭N/A IP 🕐2024-04-18 12:15:09

Magnificent: 《深入理解Linux内核》《Linux内核设计与实现》，Linux内核代码，这三者结合着看，就能理解操作系统怎么运作的了。我阅读得比较多的英文书籍，就是前面这两本。 👍🏽0 💭N/A IP 🕐2024-03-10 10:47:36

Bird Frank: 我记得学校里先学计算机体系结构再学OS的呀。 👍🏽0 💭N/A IP 🕐2024-03-06 07:27:19

叶落知秋: 深入浅出的感觉 太棒了 👍🏽0 💭N/A IP 🕐2024-02-27 03:52:45

过客: (⊙o⊙)哇，刷到14年的回答了[飙泪笑] 👍🏽0 💭N/A IP 🕐2023-12-14 08:42:04

随风: 滴答滴答……这才是核心！ 👍🏽0 💭N/A IP 🕐2023-12-01 11:06:57

我比梅西小一岁: 真正的为人民服务 👍🏽0 💭N/A IP 🕐2023-11-29 16:49:06

黑古俚: 一堆躺在内存里等着被调用的代码 C++ 👍🏽0 💭N/A IP 🕐2023-10-31 12:19:43

xinwan66: 内核代码加载到内存中，指令指针指到哪里就运行到哪里 👍🏽0 💭N/A IP 🕐2023-10-15 19:13:41

│ └── 索尼大法: 新的cpu这还真不一定，cpu后来有了缓存，会把内存的代码加载到cpu中的缓存上跑，所以甚至可以趁着cpu刚刚加载好这代码，把内存对应的那块给偷偷改了而不影响原来的代码功能 👍🏽0 💭N/A IP 🕐2025-05-20 02:18:43

客串一回: 学到老活到老[赞] 👍🏽0 💭N/A IP 🕐2023-07-31 11:48:51

ForCode: 考古 👍🏽0 💭N/A IP 🕐2023-05-19 19:36:22

冯振: 难理解的是，有些被唤醒的程序是中断內响应，有些是中断只置位。这些程序执行，置位处理的时序也倒是难点。 👍🏽0 💭N/A IP 🕐2023-05-04 09:32:56

Albert Anne: 一切皆中断，其实中断也是最小粒度的轮询 👍🏽0 💭N/A IP 🕐2023-04-21 16:02:22

泉此方: 《深入理解linux内核》里面说到，可以把linux kernel理解成一个server 👍🏽0 💭N/A IP 🕐2023-04-18 13:08:27

想你的风: c++也是一堆函数入口等着调用 👍🏽0 💭N/A IP 🕐2023-04-17 06:52:50

Hampton: 软中断天下第一 👍🏽0 💭N/A IP 🕐2023-01-27 23:49:37

康光宇: 不管系统调用还是硬中断都按中断处理，或者至少概念上大部分一致，其实是蛮合理的，也是绝大多数CPU采用的设计。概念的一致就能带来执行逻辑的一致，利于简化CPU的设计和实现。 👍🏽0 💭N/A IP 🕐2022-10-21 12:43:33

ejjjb: 为什么很多称自己的老师为老板？ 👍🏽0 💭N/A IP 🕐2015-06-14 13:51:59

│ └── 知乎用户AtT5GD: 研究生吧 👍🏽1 💭N/A IP 🕐2018-06-05 22:00:25

林葱: 顶 👍🏽0 💭N/A IP 🕐2015-05-23 17:53:52

3号线: 感谢，解决了一直以来的疑问 👍🏽0 💭N/A IP 🕐2015-05-18 12:34:40

御宅暴君: 其实不用学习「架构」那么细碎的东西，学「计算机组成」就知道是什么回事了。Coursera 上就有对应的北京大学公开课。 👍🏽0 💭N/A IP 🕐2015-01-02 23:45:02

好生: 不得不赞 👍🏽0 💭N/A IP 🕐2014-08-03 00:14:30

一直是菜鸡: 我當初剛剛開始接觸Linux的時候，就是一直沒有弄明白這一點，後來開始明白了，也沒有總結的像您一樣精闢。 👍🏽0 💭N/A IP 🕐2014-05-10 00:57:46

一直是菜鸡: 說的太對了。 👍🏽0 💭N/A IP 🕐2014-05-10 00:56:38

Maker: 拨开云雾，豁然开朗！ 👍🏽0 💭N/A IP 🕐2017-07-03 10:04:19

Mr Reliable: 你老板说的确实很经典，很形象 👍🏽0 💭N/A IP 🕐2017-03-21 01:01:17

龙瑜: 得力嘻嘻嘻嘻嘻 👍🏽0 💭N/A IP 🕐2017-01-01 07:48:55

│ └── Newdawn: 海贼王？ 👍🏽0 💭N/A IP 🕐2017-06-12 19:42:16

王斌: ⼀⼃ 👍🏽0 💭N/A IP 🕐2016-07-17 19:03:32

phope2000: user space通过系统调用（sys call）跟kernel space进行交互 👍🏽0 💭N/A IP 🕐2016-06-02 20:50:29

慕容渊: 晕，那么久的坑。。。 👍🏽0 💭N/A IP 🕐2016-04-18 01:54:48

manxisuo: timer interrupt是硬件中断吗？ 👍🏽0 💭N/A IP 🕐2016-02-06 11:12:05

先民之识: 讲的也对，但是假如时钟中断一只有的话，操作系统确实每隔一段时间（比如10ms）运行一下啊。 👍🏽0 💭N/A IP 🕐2016-01-24 15:03:29

努力做人: 除了通过系统调用产生的软中断以及IO设备产生的硬终端，内核肯定还有很多其他的线程在运行 👍🏽0 💭N/A IP 🕐2020-11-02 10:13:26

x1000: 正解，你遇到了好老师！ 👍🏽0 💭N/A IP 🕐2022-10-15 08:17:33

搬砖一工兵: 当年我的老师也说操作系统就是一个时钟中断。 👍🏽0 💭N/A IP 🕐2022-10-08 18:15:53

今天聊点啥: 写得非常棒，透彻! 👍🏽0 💭N/A IP 🕐2022-10-01 02:02:19

tyi3z: [赞同] 👍🏽0 💭N/A IP 🕐2022-06-10 10:23:33

王康: 答案为不是。全是用户态的进程，通过系统调用进入内核态，再陷入中断等待 👍🏽0 💭N/A IP 🕐2022-05-25 12:07:55

可可可: 其实从单片机和汇编学起更有利于理解操作系统和C语言 👍🏽0 💭N/A IP 🕐2022-05-23 19:51:16

更深的蓝: 具体到单个核心，确实这样的。不过多核并发，大部分时候总有核心在处理内核动作。 👍🏽0 💭N/A IP 🕐2022-05-07 13:49:29

pursuemoon: 第一句话就比很多人理解得更好了 👍🏽0 💭N/A IP 🕐2022-05-05 09:36:57