0
00:00:00,000 --> 00:00:06,680


1
00:00:06,720 --> 00:00:10,080
现在我们来继续讲

2
00:00:10,120 --> 00:00:12,400
什么是操作系统

3
00:00:12,440 --> 00:00:14,680
大家想象操作系统是什么样的

4
00:00:14,720 --> 00:00:16,000
它是一个程序

5
00:00:16,040 --> 00:00:17,840
它和其它程序是什么样的关系

6
00:00:17,880 --> 00:00:21,480
然后它有些什么样的组成

7
00:00:21,520 --> 00:00:24,280
它有些什么样的特征

8
00:00:24,320 --> 00:00:27,240
我们首先来看什么是操作系统

9
00:00:27,280 --> 00:00:28,160
操作系统实际上

10
00:00:28,200 --> 00:00:31,600
没有一个明确的定义

11
00:00:31,640 --> 00:00:33,960
它哪些功能算是操作系统里的

12
00:00:34,000 --> 00:00:37,800
那些功能是应用软件或者说硬件的

13
00:00:37,840 --> 00:00:41,880
实际上随着操作系统的发展

14
00:00:41,920 --> 00:00:44,560
操作系统内涵实际上是在不断变化的

15
00:00:44,600 --> 00:00:47,600
我们现在给操作系统是给出一个解释

16
00:00:47,640 --> 00:00:49,080
有一种解释说

17
00:00:49,120 --> 00:00:52,040
操作系统是一个控制程序

18
00:00:52,080 --> 00:00:53,440
它是一个系统软件

19
00:00:53,480 --> 00:00:57,960
它给用户提供一个运行的环境

20
00:00:58,000 --> 00:01:00,800
用户使用计算机系统的时候

21
00:01:00,840 --> 00:01:02,800
提供所需要的服务

22
00:01:02,840 --> 00:01:04,480
如果说用户的使用不当

23
00:01:04,520 --> 00:01:05,200
那么这个时候

24
00:01:05,240 --> 00:01:09,080
它需要进行项目的一些错误处理

25
00:01:09,120 --> 00:01:12,080
如果说用户在使用过程中

26
00:01:12,120 --> 00:01:14,240
我是不是能给它一些协助

27
00:01:14,280 --> 00:01:16,880
比如说你在输某一条命令的时候

28
00:01:16,920 --> 00:01:20,240
输了半截你忘掉了 后面是什么内容

29
00:01:20,280 --> 00:01:22,760
这个时候它是不是能给出一些提示

30
00:01:22,800 --> 00:01:24,520
这是我们第一个理解

31
00:01:24,560 --> 00:01:27,200
第二个理解操作系统

32
00:01:27,240 --> 00:01:31,840
它是一个资源管理器

33
00:01:31,880 --> 00:01:34,680
实际上就是说我们计算机硬件

34
00:01:34,720 --> 00:01:36,160
和应用程序之间

35
00:01:36,200 --> 00:01:39,760
用操作系统来作为它的一个中间层

36
00:01:39,800 --> 00:01:44,560
它为计算机应用程序来管理

37
00:01:44,600 --> 00:01:48,120
所有的计算机软硬件资源

38
00:01:48,160 --> 00:01:50,200
以协调于各个应用程序

39
00:01:50,240 --> 00:01:52,360
在使用这些资源的时候

40
00:01:52,400 --> 00:01:55,040
能够友好地使用下去

41
00:01:55,080 --> 00:01:56,720
那么具体说起来就是

42
00:01:56,760 --> 00:01:59,840
如果说所有的资源都是由我专用的

43
00:01:59,880 --> 00:02:02,360
那么这个时候我的使用肯定会没问题

44
00:02:02,400 --> 00:02:06,920
但是如果说多个应用程序交替着来使用

45
00:02:06,960 --> 00:02:08,080
那么这个时候这资源

46
00:02:08,120 --> 00:02:11,360
如何使用就会有一些问题了

47
00:02:11,400 --> 00:02:16,200
比如说像内存 你在用我也在用

48
00:02:16,240 --> 00:02:17,960
这个时候我到底

49
00:02:18,000 --> 00:02:21,120
两个应用它们之间各分配多少呢

50
00:02:21,160 --> 00:02:24,440
有可能给你分配多了 给它分配少了

51
00:02:24,480 --> 00:02:27,320
而你的需要又跟分配的结果不一致

52
00:02:27,360 --> 00:02:28,960
那这个时候对操作系统来说

53
00:02:29,000 --> 00:02:33,280
我就需要做一个高效的判断

54
00:02:33,320 --> 00:02:34,920
来使得我们在这里

55
00:02:34,960 --> 00:02:37,200
能够按照应用程序的需要

56
00:02:37,240 --> 00:02:38,960
给它分配合理的资源

57
00:02:39,000 --> 00:02:41,680
这是我们操作系统提供的高效使用

58
00:02:41,720 --> 00:02:43,360
所要达到的目标

59
00:02:43,400 --> 00:02:44,840
然后第二个是说

60
00:02:44,880 --> 00:02:47,160
我们可能都需要很多的资源

61
00:02:47,200 --> 00:02:48,680
这个时候操作系统

62
00:02:48,720 --> 00:02:51,320
要负责解决这种需求上的差异

63
00:02:51,360 --> 00:02:54,600
实现它的公平

64
00:02:54,640 --> 00:02:56,400
操作系统表现形式

65
00:02:56,440 --> 00:02:57,760
可能会有多种多样

66
00:02:57,800 --> 00:02:59,960
比如说我们windows我们的Linux

67
00:03:00,000 --> 00:03:01,680
它的表现是完全不一样的

68
00:03:01,720 --> 00:03:04,120
但是从操作系统内部结构上来讲

69
00:03:04,160 --> 00:03:06,040
它基本上可以分成这样几个部分

70
00:03:06,080 --> 00:03:10,240
说操作系统在中间 下面是硬件

71
00:03:10,280 --> 00:03:11,400
上面是应用

72
00:03:11,440 --> 00:03:12,760
应用我们就可以把它

73
00:03:12,800 --> 00:03:17,080
分成系统应用和应用程序

74
00:03:17,120 --> 00:03:19,080
这两个部分对于我们来讲

75
00:03:19,120 --> 00:03:20,800
我们学操作系统的人

76
00:03:20,840 --> 00:03:22,040
就是要来做操作系统

77
00:03:22,080 --> 00:03:24,840
那么你是在硬件基础上做操作系统

78
00:03:24,880 --> 00:03:27,120
这属于系统设计者

79
00:03:27,160 --> 00:03:30,360
如果说你是写应用程序的人

80
00:03:30,400 --> 00:03:32,160
或者写系统应用的人

81
00:03:32,200 --> 00:03:34,880
这个时候我利用操作系统的功能

82
00:03:34,920 --> 00:03:39,480
给出应用程序和系统应用

83
00:03:39,520 --> 00:03:41,960
如果说你是一个应用程序的使用者

84
00:03:42,000 --> 00:03:44,560
这个时候你直接使用的应用程序

85
00:03:44,600 --> 00:03:46,920
但是即使这样的话你理解操作系统

86
00:03:46,960 --> 00:03:52,520
也有利于你更好地使用计算机系统

87
00:03:52,560 --> 00:03:54,080
操作系统实际上就是

88
00:03:54,120 --> 00:03:58,080
在硬件进行一层隔离

89
00:03:58,120 --> 00:03:59,600
对上面的应用 

90
00:03:59,640 --> 00:04:02,600
提供我们通常所见到的逻辑这些资源

91
00:04:02,640 --> 00:04:05,600
比如说进程 文件 地址空间

92
00:04:05,640 --> 00:04:07,240
这都是在操作系统之后

93
00:04:07,280 --> 00:04:09,320
给用户程序看到的情况

94
00:04:09,360 --> 00:04:10,800
操作系统是一个软件

95
00:04:10,840 --> 00:04:13,040
在我们软件划分当中

96
00:04:13,080 --> 00:04:14,360
这是我们操作系统

97
00:04:14,400 --> 00:04:17,120
实际上我们可以把软件分成

98
00:04:17,160 --> 00:04:19,840
应用软件和系统软件

99
00:04:19,880 --> 00:04:21,040
系统软件我们又可以

100
00:04:21,080 --> 00:04:23,320
把它分成系统应用和操作系统

101
00:04:23,360 --> 00:04:24,840
而在操作系统里面

102
00:04:24,880 --> 00:04:27,080
核心的内容是我们的内核

103
00:04:27,120 --> 00:04:28,920
而这里的命令行

104
00:04:28,960 --> 00:04:32,680
由于它和操作系统内核关系非常密切

105
00:04:32,720 --> 00:04:33,600
我们把它划在这里头

106
00:04:33,640 --> 00:04:34,400
实际上有时候也会

107
00:04:34,440 --> 00:04:37,600
把它认为系统软件的一个组成部分

108
00:04:37,640 --> 00:04:39,640
  

109
00:04:39,680 --> 00:04:40,840
我们在操作系统里

110
00:04:40,880 --> 00:04:43,080
到底有一些什么样的组成

111
00:04:43,120 --> 00:04:45,800
首先说我们有内核

112
00:04:45,840 --> 00:04:47,560
实现我们刚才所说到的

113
00:04:47,600 --> 00:04:50,480
资源的管理功能

114
00:04:50,520 --> 00:04:52,280
操作系统之上用户要使用

115
00:04:52,320 --> 00:04:55,880
实际上我们在这提供了两种命令接口

116
00:04:55,920 --> 00:04:57,880
一个是命令行接口

117
00:04:57,920 --> 00:05:00,800
这个时候用户需要去敲键盘输命令

118
00:05:00,840 --> 00:05:03,960
另一种是图形用户接口GUI

119
00:05:04,000 --> 00:05:06,960
这个时候实际上我们是把命令

120
00:05:07,000 --> 00:05:09,240
转换成我们图形用户接口的

121
00:05:09,280 --> 00:05:10,880
一些基本读数

122
00:05:10,920 --> 00:05:15,680
比如说在这里的窗口 图标 菜单和指针

123
00:05:15,720 --> 00:05:16,680
有了这些之后

124
00:05:16,720 --> 00:05:19,440
我去看文件系统的文件的图标

125
00:05:19,480 --> 00:05:21,240
那我就对应着某一个文件

126
00:05:21,280 --> 00:05:22,920
这样的话方便用户来使用

127
00:05:22,960 --> 00:05:24,280
这个时候我们能达到一种效果

128
00:05:24,320 --> 00:05:26,120
是所见即所得

129
00:05:26,160 --> 00:05:28,480
  

130
00:05:28,520 --> 00:05:30,800
操作系统和外界的关系

131
00:05:30,840 --> 00:05:33,880
实际上我们在这个图可以很直观表现出来

132
00:05:33,920 --> 00:05:35,200
操作系统是我们

133
00:05:35,240 --> 00:05:38,240
整个计算机系统里的核心软件

134
00:05:38,280 --> 00:05:39,680
然后在外面构造我们的

135
00:05:39,720 --> 00:05:42,160
提供对外接口和一些应用

136
00:05:42,200 --> 00:05:45,280
用户就可以来使用

137
00:05:45,320 --> 00:05:47,440
系统所提供的服务了

138
00:05:47,480 --> 00:05:49,960
这是我们用户所在的位置

139
00:05:50,000 --> 00:05:51,880
对于我们这学期课来讲

140
00:05:51,920 --> 00:05:54,800
我们的ucore小操作系统

141
00:05:54,840 --> 00:05:57,800
它在提供一些什么 我们从下往上

142
00:05:57,840 --> 00:06:00,120
中间两个黄色的部分

143
00:06:00,160 --> 00:06:02,240
是我们操作系统的内容

144
00:06:02,280 --> 00:06:05,040
下面是硬件 我们写了几种

145
00:06:05,080 --> 00:06:06,760
我们在ucore实验里头会

146
00:06:06,800 --> 00:06:14,040
涉及到的硬件 串口 磁盘和存储

147
00:06:14,080 --> 00:06:16,880
我在这有一个硬件抽象层

148
00:06:16,920 --> 00:06:21,000
硬件抽象层把底下这些做一个屏蔽

149
00:06:21,040 --> 00:06:23,920
提供一个标准的接口

150
00:06:23,960 --> 00:06:26,280
然后在这里实现我们操作系统功能

151
00:06:26,320 --> 00:06:29,280
操作系统功能是各种各样的驱动

152
00:06:29,320 --> 00:06:34,000
串口驱动 磁盘驱动 物理内存的管理

153
00:06:34,040 --> 00:06:36,160
操作系统内核提供的服务

154
00:06:36,200 --> 00:06:38,160
比如说我们的信号

155
00:06:38,200 --> 00:06:38,600
这样的话

156
00:06:38,640 --> 00:06:40,560
我们在执行一个程序过程当中

157
00:06:40,600 --> 00:06:43,880
我就可以强行让它停下来按Ctrl-C

158
00:06:43,920 --> 00:06:46,640
然后我们可以提供文件系统

159
00:06:46,680 --> 00:06:48,800
这个时候我就可以把大量的数据

160
00:06:48,840 --> 00:06:52,400
以人比较好理解的形式组织起来

161
00:06:52,440 --> 00:06:54,240
然后我们在里面提供虚拟存储

162
00:06:54,280 --> 00:06:57,280
提供虚拟存储以后我们用户

163
00:06:57,320 --> 00:06:58,560
就可以使用到

164
00:06:58,600 --> 00:07:01,800
大于物理内存的储存空间

165
00:07:01,840 --> 00:07:04,960
然后我们在这里提供处理机调度

166
00:07:05,000 --> 00:07:06,920
这个时候我们就可以在一台机器上

167
00:07:06,960 --> 00:07:09,680
让多个应用程序交替运行

168
00:07:09,720 --> 00:07:11,000
提供这些服务

169
00:07:11,040 --> 00:07:14,320
都封装在系统调用接口之上

170
00:07:14,360 --> 00:07:18,200
通过系统调用接口 上层应用

171
00:07:18,240 --> 00:07:21,640
系统库 编译器 解释器

172
00:07:21,680 --> 00:07:23,120
和我们命令行应用 

173
00:07:23,160 --> 00:07:24,960
这都是提供的系统应用

174
00:07:25,000 --> 00:07:27,240
然后我们写的应用程序是

175
00:07:27,280 --> 00:07:29,640
在这上面利用系统调用和库

176
00:07:29,680 --> 00:07:30,560
提供的功能

177
00:07:30,600 --> 00:07:32,040
来实现我们应用的功能

178
00:07:32,080 --> 00:07:33,920
操作系统软件和

179
00:07:33,960 --> 00:07:36,720
其它课程里面说到应用程序

180
00:07:36,760 --> 00:07:38,040
它也是一个软件

181
00:07:38,080 --> 00:07:40,560
这两者之间有什么样的差别

182
00:07:40,600 --> 00:07:42,160
也就是操作系统内核

183
00:07:42,200 --> 00:07:43,520
它有一些什么样的特征

184
00:07:43,560 --> 00:07:44,920
这里列出来的是

185
00:07:44,960 --> 00:07:47,720
操作系统所具有四个特征

186
00:07:47,760 --> 00:07:51,200
并发 共享 虚拟和异步

187
00:07:51,240 --> 00:07:54,360
并发是指说我们在操作系统当中

188
00:07:54,400 --> 00:07:58,320
有多个正在运行的应用程序

189
00:07:58,360 --> 00:08:01,280
那么它需要操作系统管理和调度

190
00:08:01,320 --> 00:08:02,320
具体什么意思

191
00:08:02,360 --> 00:08:05,560
就是我们如果多个应用程序交替运行

192
00:08:05,600 --> 00:08:08,360
我需要知道当前每一个应用

193
00:08:08,400 --> 00:08:09,720
都执行到什么位置

194
00:08:09,760 --> 00:08:12,320
当前正在执行的是哪个应用

195
00:08:12,360 --> 00:08:13,280
  

196
00:08:13,320 --> 00:08:15,360
如果说应用之间有切换的时候

197
00:08:15,400 --> 00:08:17,160
那切换到下一个应用的时候

198
00:08:17,200 --> 00:08:19,600
它上次执行到什么位置

199
00:08:19,640 --> 00:08:21,320
那这次我从什么地方开始

200
00:08:21,360 --> 00:08:23,480
当时的状态是什么样子

201
00:08:23,520 --> 00:08:26,080
那我在这都用操作系统来维护

202
00:08:26,120 --> 00:08:27,520
第二个特征是共享

203
00:08:27,560 --> 00:08:30,960
共享是指说我们多个应用

204
00:08:31,000 --> 00:08:32,200
并发运行的时候

205
00:08:32,240 --> 00:08:33,840
宏观上要体现出

206
00:08:33,880 --> 00:08:35,800
它们同时在访问资源的情况

207
00:08:35,840 --> 00:08:39,280
微观上要实现它们的互斥访问

208
00:08:39,320 --> 00:08:42,720
比如说我们说到的内存

209
00:08:42,760 --> 00:08:45,040
两个应用同时访问内存

210
00:08:45,080 --> 00:08:46,720
这个时候我每个应用

211
00:08:46,760 --> 00:08:48,320
需要知道它访问是哪个

212
00:08:48,360 --> 00:08:49,600
另一个应用访问的是哪个

213
00:08:49,640 --> 00:08:52,800
它们两之间不能访问错了

214
00:08:52,840 --> 00:08:55,480
我需要保护的这些内存资源

215
00:08:55,520 --> 00:08:57,200
不能让另外一个应用去访问

216
00:08:57,240 --> 00:08:59,600
而在微观上 这个时候

217
00:08:59,640 --> 00:09:02,280
我需要对它做很好的隔离

218
00:09:02,320 --> 00:09:05,000
我们知道在数据总线上任何一个时刻

219
00:09:05,040 --> 00:09:08,720
只有一个应用去访问存储单元

220
00:09:08,760 --> 00:09:11,960
这就是我们所说的微观上的互斥

221
00:09:12,000 --> 00:09:13,880
然后再一个是虚拟

222
00:09:13,920 --> 00:09:17,400
也就是说我要通过交替运行

223
00:09:17,440 --> 00:09:19,120
使每一个用户感觉到

224
00:09:19,160 --> 00:09:21,360
整个计算机都是

225
00:09:21,400 --> 00:09:24,680
由它一个用户在专门提供服务

226
00:09:24,720 --> 00:09:27,200
如何做到这点实际上就是由操作系统

227
00:09:27,240 --> 00:09:30,080
在每个应用执行的时候这种交替

228
00:09:30,120 --> 00:09:31,920
由于交替的频率非常高

229
00:09:31,960 --> 00:09:35,920
让用户在用的时候感觉不太出来

230
00:09:35,960 --> 00:09:38,640
这台机器还有其它用户在用

231
00:09:38,680 --> 00:09:41,880
当然我们这里负载大到一定程度

232
00:09:41,920 --> 00:09:44,120
用户是可以感觉到的

233
00:09:44,160 --> 00:09:46,960
再有一个是异步 异步是指说

234
00:09:47,000 --> 00:09:50,120
由于我们程序是走走停停的

235
00:09:50,160 --> 00:09:51,480
这种走走停停

236
00:09:51,520 --> 00:09:54,320
它的行为是不是可预测的

237
00:09:54,360 --> 00:09:55,760
在这里实际上

238
00:09:55,800 --> 00:09:58,000
我们需要由操作系统来提供

239
00:09:58,040 --> 00:10:01,000
只要用户的输入是一致的

240
00:10:01,040 --> 00:10:02,640
那么这个时候它的输出结果

241
00:10:02,680 --> 00:10:05,280
就应该是不变的

242
00:10:05,320 --> 00:10:07,200
当然如果说你的那个应用

243
00:10:07,240 --> 00:10:09,480
就是需要知道跟时间相关的

244
00:10:09,520 --> 00:10:11,000
这种走走停停的信息

245
00:10:11,040 --> 00:10:13,600
我们也是可以在操作系统支持之下

246
00:10:13,640 --> 00:10:16,920
能够发现时间上的差异

247
00:10:16,960 --> 00:10:18,360
这就是我们在这里说到的

248
00:10:18,400 --> 00:10:19,520
操作系统的特征

249
00:10:19,560 --> 00:10:20,680


250
00:10:20,720 --> 00:10:20,720