0
00:00:00,000 --> 00:00:07,240


1
00:00:07,320 --> 00:00:10,640
下面我们来讨论目录 文件别名

2
00:00:10,680 --> 00:00:13,080
和具体的文件系统

3
00:00:13,120 --> 00:00:15,120
文件多到一定数目之后

4
00:00:15,160 --> 00:00:17,440
我们要想对它进行有效的管理

5
00:00:17,480 --> 00:00:20,120
这时候我们就必须引入分层的结构

6
00:00:20,160 --> 00:00:21,680
也就说把若干个文件

7
00:00:21,720 --> 00:00:23,840
以目录的形式组织起来

8
00:00:23,880 --> 00:00:25,200
比如说在这里头

9
00:00:25,240 --> 00:00:26,520
给出的是文件系统里的

10
00:00:26,560 --> 00:00:28,040
一种组织方式

11
00:00:28,080 --> 00:00:31,280
圆圈表示我们基本的 普通的文件

12
00:00:31,320 --> 00:00:34,880
在这里这些方块的 就是目录

13
00:00:34,920 --> 00:00:37,920
它是一种特殊的文件

14
00:00:37,960 --> 00:00:40,360
这个特殊的文件里存的内容呢

15
00:00:40,400 --> 00:00:43,040
是用来表示其它文件的信息

16
00:00:43,080 --> 00:00:44,640
所以它是特殊的

17
00:00:44,680 --> 00:00:47,600
文件内容是文件的索引表

18
00:00:47,640 --> 00:00:49,800
一条索引呢 就是文件名

19
00:00:49,840 --> 00:00:52,520
和指向文件的指针

20
00:00:52,560 --> 00:00:53,680
有了这个之后

21
00:00:53,720 --> 00:00:55,440
我们就可以把所有的文件

22
00:00:55,480 --> 00:00:57,200
组织成一个树状结构

23
00:00:57,240 --> 00:00:58,680
这时候我们如何来标识

24
00:00:58,720 --> 00:01:00,840
一个特定的文件呢

25
00:01:00,880 --> 00:01:02,560
每一个文件呢 在我们这里呢

26
00:01:02,600 --> 00:01:04,640
对应过来是一条

27
00:01:04,680 --> 00:01:08,320
从根目录开始的一条路径

28
00:01:08,360 --> 00:01:10,280
第一级 根目录

29
00:01:10,320 --> 00:01:14,440
然后找着它的下一级目录的名字

30
00:01:14,480 --> 00:01:18,040
这是我们第一级根目录里的目录项

31
00:01:18,080 --> 00:01:20,000
到第二级目录的时候呢

32
00:01:20,040 --> 00:01:21,960
它又有它的目录项

33
00:01:22,000 --> 00:01:24,120
根据你这个文件的路径

34
00:01:24,160 --> 00:01:27,840
一直找到最后文件的内容

35
00:01:27,880 --> 00:01:29,080
有这种方式之后

36
00:01:29,120 --> 00:01:31,840
我们就可以以路径的形式

37
00:01:31,880 --> 00:01:34,160
来标识每一个文件

38
00:01:34,200 --> 00:01:35,880
这样的话方便用户的访问

39
00:01:35,920 --> 00:01:37,360
这里所谓的方便呢 是指

40
00:01:37,400 --> 00:01:40,560
我方便用户的记忆和分类

41
00:01:40,600 --> 00:01:42,720
我们再换一个 这个地方呢

42
00:01:42,760 --> 00:01:45,760
实际上是从program/p/list

43
00:01:45,800 --> 00:01:50,160
最后找着我的这个文件 名字叫list

44
00:01:50,200 --> 00:01:52,160
用这种方式组织之后

45
00:01:52,200 --> 00:01:54,160
我们在目录上的操作

46
00:01:54,200 --> 00:01:57,080
就跟其它的文件有一些不一样的地方

47
00:01:57,120 --> 00:01:58,840
在目录里典型的操作呢

48
00:01:58,880 --> 00:02:01,800
是说我会有去检索

49
00:02:01,840 --> 00:02:03,960
我找我需要那个文件

50
00:02:04,000 --> 00:02:07,000
然后我创建一个新的文件的时候

51
00:02:07,040 --> 00:02:08,360
因为我在文件系统里

52
00:02:08,400 --> 00:02:09,480
存了一个新的文件

53
00:02:09,520 --> 00:02:11,840
那么这时候我必须增加相应的目录项

54
00:02:11,880 --> 00:02:14,680
这也会在目录里头呢 有相应的操作

55
00:02:14,720 --> 00:02:16,600
然后我删除一个文件

56
00:02:16,640 --> 00:02:19,600
也会需要你在相应的目录里呢

57
00:02:19,640 --> 00:02:22,200
把对应的目录项删掉

58
00:02:22,240 --> 00:02:23,840
然后我会去列目录

59
00:02:23,880 --> 00:02:24,880
看看这个目录里

60
00:02:24,920 --> 00:02:28,640
到底有哪些文件和子目录

61
00:02:28,680 --> 00:02:31,200
我会对文件重命名

62
00:02:31,240 --> 00:02:32,840
你改文件的名字

63
00:02:32,880 --> 00:02:34,040
那这时候目录项里的 

64
00:02:34,080 --> 00:02:37,280
相应的文件属性 文件名

65
00:02:37,320 --> 00:02:40,400
你也需要去进行相应的修改

66
00:02:40,440 --> 00:02:42,520
再有一个是遍历路径

67
00:02:42,560 --> 00:02:44,120
也就相当于我想找某一个文件

68
00:02:44,160 --> 00:02:46,560
是从根目录一级一级找下去

69
00:02:46,600 --> 00:02:48,000
最后找那个文件

70
00:02:48,040 --> 00:02:50,960
这是在目录上的典型操作

71
00:02:51,000 --> 00:02:54,320
这些操作呢 对于操作系统来说

72
00:02:54,360 --> 00:02:56,640
它都是封装到内核里头的

73
00:02:56,680 --> 00:03:00,360
只能由内核来对目录进行修改

74
00:03:00,400 --> 00:03:01,800
这样的话 就可以保证

75
00:03:01,840 --> 00:03:04,720
这种目录的映射的完整性

76
00:03:04,760 --> 00:03:06,800
用户进行这个操作的时候他需要改

77
00:03:06,840 --> 00:03:08,000
这个改动怎么来做呢

78
00:03:08,040 --> 00:03:09,520
通过系统调用

79
00:03:09,560 --> 00:03:10,960
用户来通过系统调用

80
00:03:11,000 --> 00:03:14,440
来对目录进行相应的操作

81
00:03:14,480 --> 00:03:16,640
这是目录

82
00:03:16,680 --> 00:03:20,040
目录的实现呢 是描述我目录里的

83
00:03:20,080 --> 00:03:21,520
这些文件的列表

84
00:03:21,560 --> 00:03:23,080
我怎么来组织

85
00:03:23,120 --> 00:03:24,120
最简单一种做法呢

86
00:03:24,160 --> 00:03:26,120
是把它组织成一个线性的表

87
00:03:26,160 --> 00:03:28,880
这时候的问题是说如果这个表很大

88
00:03:28,920 --> 00:03:31,280
那这时候检索 或者说增删

89
00:03:31,320 --> 00:03:32,760
它的时间会很长

90
00:03:32,800 --> 00:03:35,680
但是它的好处是我编程比较简单

91
00:03:35,720 --> 00:03:36,920
然后另一种做法呢

92
00:03:36,960 --> 00:03:38,840
我是把目录里这些文件呢

93
00:03:38,880 --> 00:03:40,680
组织成一个哈希表

94
00:03:40,720 --> 00:03:44,200
先做哈希 然后再进行后续的操作

95
00:03:44,240 --> 00:03:46,760
这种做法呢 由于哈希的缘故

96
00:03:46,800 --> 00:03:48,920
它可以减少搜索的时间

97
00:03:48,960 --> 00:03:51,720
也会有另外一个问题 就是两个文件名

98
00:03:51,760 --> 00:03:52,720
它做哈希之后

99
00:03:52,760 --> 00:03:54,680
可能哈希结果是一致的

100
00:03:54,720 --> 00:03:56,320
这时候会产生冲突

101
00:03:56,360 --> 00:03:58,800
那么冲突呢 我需要在哈希表里

102
00:03:58,840 --> 00:04:00,240
有相应的解决

103
00:04:00,280 --> 00:04:01,600
这样做之后呢

104
00:04:01,640 --> 00:04:03,720
我目录表里的每一项呢

105
00:04:03,760 --> 00:04:06,920
它的长度是固定的

106
00:04:06,960 --> 00:04:09,080
接下来我们说文件别名

107
00:04:09,120 --> 00:04:10,960
也就说我有一个文件

108
00:04:11,000 --> 00:04:14,280
我想给它起两个或者多个名字的时候

109
00:04:14,320 --> 00:04:15,680
我怎么办

110
00:04:15,720 --> 00:04:17,800
首先我们在这儿看这个例子

111
00:04:17,840 --> 00:04:20,720
在这里头呢我有一个文件

112
00:04:20,760 --> 00:04:22,520


113
00:04:22,560 --> 00:04:25,200
这有它的路径 count

114
00:04:25,240 --> 00:04:28,560
这两个最后指到是同一个实体

115
00:04:28,600 --> 00:04:30,280
我们这种做法的缘故呢

116
00:04:30,320 --> 00:04:34,680
是为了方便共享 减少存储空间

117
00:04:34,720 --> 00:04:37,000
文件系统中我怎么来表示它

118
00:04:37,040 --> 00:04:40,400
在这里头呢 这是另外一个例子

119
00:04:40,440 --> 00:04:43,200
这三个说的 实际上最后都是同一个

120
00:04:43,240 --> 00:04:44,560


121
00:04:44,600 --> 00:04:46,440
它的实现办法呢 我们这有两种 

122
00:04:46,480 --> 00:04:48,160
一种叫硬链接

123
00:04:48,200 --> 00:04:51,520
也就说 多个文件的目录项

124
00:04:51,560 --> 00:04:54,360
最后都指向同一个文件

125
00:04:54,400 --> 00:04:55,640
比如说在这里头

126
00:04:55,680 --> 00:04:58,400
我们知道这一个和这一个

127
00:04:58,440 --> 00:05:00,760
另一种做法叫软链接

128
00:05:00,800 --> 00:05:03,240
它的做法呢 是以快捷方式

129
00:05:03,280 --> 00:05:05,760
来指向其它文件

130
00:05:05,800 --> 00:05:07,360
它的文件描述出来

131
00:05:07,400 --> 00:05:09,280
仍然是各自独立的

132
00:05:09,320 --> 00:05:11,600
只是说链接文件里头呢

133
00:05:11,640 --> 00:05:16,320
它存的是另一个文件的 完整的路径

134
00:05:16,360 --> 00:05:20,200
它以这种方式来实现文件别名

135
00:05:20,240 --> 00:05:22,240
第一种方式呢 就会涉及到一个问题

136
00:05:22,280 --> 00:05:23,680
如果说我一个删除操作

137
00:05:23,720 --> 00:05:24,560
我到什么时候 

138
00:05:24,600 --> 00:05:27,240
实实在在把这个文件删除掉

139
00:05:27,280 --> 00:05:30,040
它就会是 我只要删到最后一个

140
00:05:30,080 --> 00:05:31,920
指向它的文件名的时候

141
00:05:31,960 --> 00:05:35,000
我才会把这个文件实体删掉

142
00:05:35,040 --> 00:05:37,480
而软链接呢 我删除的时候呢

143
00:05:37,520 --> 00:05:40,840
删除别名和删除其它的文件是一样的

144
00:05:40,880 --> 00:05:43,640
删除别名 实际上文件不受任何影响

145
00:05:43,680 --> 00:05:46,520
删除文件之后呢 你原来的别名

146
00:05:46,560 --> 00:05:49,280
它指向的文件就是不存在了

147
00:05:49,320 --> 00:05:51,480
这是文件别名

148
00:05:51,520 --> 00:05:52,440
还有一个问题呢

149
00:05:52,480 --> 00:05:55,880
是文件目录中的循环

150
00:05:55,920 --> 00:05:58,880
我可以指向下一级子目录

151
00:05:58,920 --> 00:06:00,400
那我的子目录可不可以

152
00:06:00,440 --> 00:06:02,520
指回到它的父目录呢

153
00:06:02,560 --> 00:06:04,160
这时候 如果你这样指的话

154
00:06:04,200 --> 00:06:05,640
就会构成循环

155
00:06:05,680 --> 00:06:08,200
比如说在这里头 你要找某一个文件

156
00:06:08,240 --> 00:06:09,440
它的子目录的子目录

157
00:06:09,480 --> 00:06:10,960
我把它指向一个循环之后

158
00:06:11,000 --> 00:06:13,480
这条路径就可以无限制的循环下去了

159
00:06:13,520 --> 00:06:15,600
这种情况怎么处理呢

160
00:06:15,640 --> 00:06:17,800
我们处理办法呢有这样几种

161
00:06:17,840 --> 00:06:21,440
一种是 我加链接的时候

162
00:06:21,480 --> 00:06:25,360
我只能是文件 不允许目录的链接

163
00:06:25,400 --> 00:06:26,920
这是一种做法

164
00:06:26,960 --> 00:06:28,400
还有一种做法呢是说

165
00:06:28,440 --> 00:06:30,240
我在这里头增加链接的时候

166
00:06:30,280 --> 00:06:32,440
我用检测算法来检测

167
00:06:32,480 --> 00:06:35,120
这跟我们死锁检测差不太多

168
00:06:35,160 --> 00:06:37,400
我可以用银行家算法

169
00:06:37,440 --> 00:06:39,960
但这时候呢你的检测开销会比较大

170
00:06:40,000 --> 00:06:42,000
所以在实际的做法里头呢

171
00:06:42,040 --> 00:06:43,720
通常情况下 我是限制

172
00:06:43,760 --> 00:06:46,240
你可以检索下去的长度

173
00:06:46,280 --> 00:06:47,040
超过这个长度

174
00:06:47,080 --> 00:06:48,440
我就不再给你往下检索了

175
00:06:48,480 --> 00:06:50,760
这样的话也就减少了

176
00:06:50,800 --> 00:06:53,840
这种由于循环所带来的问题

177
00:06:53,880 --> 00:06:55,080
有了这个之后

178
00:06:55,120 --> 00:06:57,400
那我们来看 接下来是

179
00:06:57,440 --> 00:06:58,720
我如何找一个文件

180
00:06:58,760 --> 00:07:01,240
这就是我们这里的名字解析

181
00:07:01,280 --> 00:07:04,360
在很多地方呢有名字解析的问题

182
00:07:04,400 --> 00:07:06,960
这里说名字解析是把一个逻辑的名字

183
00:07:07,000 --> 00:07:09,600
转换成它的物理资源

184
00:07:09,640 --> 00:07:11,520
比如说我们这里的文件

185
00:07:11,560 --> 00:07:13,360
对于文件系统里的名字解析呢

186
00:07:13,400 --> 00:07:15,120
就是我给你一个路径

187
00:07:15,160 --> 00:07:16,640
然后你告诉我

188
00:07:16,680 --> 00:07:19,160
这个路径所对应的文件存在哪

189
00:07:19,200 --> 00:07:21,040
把它的内容读出来

190
00:07:21,080 --> 00:07:24,080
它的实际做法呢就是遍历文件目录

191
00:07:24,120 --> 00:07:25,600
从根目录开始

192
00:07:25,640 --> 00:07:29,080
一直找到你要找那个文件为止

193
00:07:29,120 --> 00:07:32,760
这是文件名的解析

194
00:07:32,800 --> 00:07:34,840
在这儿给一个例子

195
00:07:34,880 --> 00:07:36,200
说我这儿有一个路径

196
00:07:36,240 --> 00:07:38,240
最后文件名是ls

197
00:07:38,280 --> 00:07:39,080
我怎么来找呢

198
00:07:39,120 --> 00:07:43,360
首先我找这个文件分区的根目录

199
00:07:43,400 --> 00:07:45,400
根目录里头的位置

200
00:07:45,440 --> 00:07:48,040
在文件系统当中是固定的

201
00:07:48,080 --> 00:07:51,680
从这儿呢我读出根目录的数据块

202
00:07:51,720 --> 00:07:53,440
里头每一个子目录

203
00:07:53,480 --> 00:07:57,440
和它的根目录里的文件对应着一项

204
00:07:57,480 --> 00:07:58,200
我在这里呢

205
00:07:58,240 --> 00:08:00,440
找着我要找bin这一项

206
00:08:00,480 --> 00:08:05,560
这一项会指向下一级目录的数据块

207
00:08:05,600 --> 00:08:07,960
我再去找着下一个 bin

208
00:08:08,000 --> 00:08:11,040
这个目录所对应的文件头

209
00:08:11,080 --> 00:08:13,080
那在这里呢读取它的数据块

210
00:08:13,120 --> 00:08:14,320
也就相当于这里头就是

211
00:08:14,360 --> 00:08:16,000
bin这个目录里

212
00:08:16,040 --> 00:08:18,520
所有文件和子目录的列表

213
00:08:18,560 --> 00:08:21,480
在那里去找 是不是ls这一项

214
00:08:21,520 --> 00:08:24,400
找到这一项之后

215
00:08:24,440 --> 00:08:26,920
我再来看

216
00:08:26,960 --> 00:08:28,320
就可以读取到

217
00:08:28,360 --> 00:08:32,400
我这个ls这个文件的内容了

218
00:08:32,440 --> 00:08:34,320
那为了方便这种查找呢

219
00:08:34,360 --> 00:08:35,800
我们就提出一种概念

220
00:08:35,840 --> 00:08:37,640
叫做当前工作目录

221
00:08:37,680 --> 00:08:39,640
它指每一个进程

222
00:08:39,680 --> 00:08:43,200
给它设定一个缺省的目录

223
00:08:43,240 --> 00:08:44,200
它的名字解析

224
00:08:44,240 --> 00:08:46,640
就从这个目录开始往下解析

225
00:08:46,680 --> 00:08:48,680
这样做的好处是在于

226
00:08:48,720 --> 00:08:50,000
如果说我这个进程

227
00:08:50,040 --> 00:08:52,520
经常就在这一个目录里进行操作的话

228
00:08:52,560 --> 00:08:55,640
它就没有必要每次都从根目录往下找

229
00:08:55,680 --> 00:08:57,440
只有在你要找切换了

230
00:08:57,480 --> 00:08:58,960
你的当前工作目录之后

231
00:08:59,000 --> 00:09:01,080
你才会从根目录里找一遍

232
00:09:01,120 --> 00:09:02,880
这样的话就会提高效率

233
00:09:02,920 --> 00:09:05,480
这时候路径就有一种相对路径

234
00:09:05,520 --> 00:09:08,800
也就说基于当前目录所进行的查找

235
00:09:08,840 --> 00:09:14,000
这是当前工作目录 和相对路径

236
00:09:14,040 --> 00:09:15,680
文件系统呢 

237
00:09:15,720 --> 00:09:17,640
在我们计算机系统起来之后

238
00:09:17,680 --> 00:09:19,600
它有个根文件系统

239
00:09:19,640 --> 00:09:21,240
通常我们访问这些数据呢

240
00:09:21,280 --> 00:09:24,440
所在文件系统必须挂接到系统当中

241
00:09:24,480 --> 00:09:25,920
才能够被访问

242
00:09:25,960 --> 00:09:27,200
比如说我们在这里

243
00:09:27,240 --> 00:09:29,840
这是一个未挂接的文件系统

244
00:09:29,880 --> 00:09:32,560
系统起来的时候呢

245
00:09:32,600 --> 00:09:35,880
它有一个根文件系统

246
00:09:35,920 --> 00:09:37,360
未被挂接文件系统呢

247
00:09:37,400 --> 00:09:39,440
需要挂接到这个根文件系统当中

248
00:09:39,480 --> 00:09:41,000
才能进行访问

249
00:09:41,040 --> 00:09:42,480
所谓挂接是指什么意思呢

250
00:09:42,520 --> 00:09:44,360
就是我把这个文件系统

251
00:09:44,400 --> 00:09:45,960
它根目录对应到

252
00:09:46,000 --> 00:09:47,480
根文件系统里某一个目录

253
00:09:47,520 --> 00:09:49,600
比如说我在这里user

254
00:09:49,640 --> 00:09:52,240
这个地方就是它的挂接点

255
00:09:52,280 --> 00:09:53,440
挂接上去之后

256
00:09:53,480 --> 00:09:57,200
我再去找这个文件系统里的某一个文件

257
00:09:57,240 --> 00:09:58,000
它的路径什么 

258
00:09:58,040 --> 00:10:01,360
从整个系统的根开始 沿着这找

259
00:10:01,400 --> 00:10:02,960
找到你挂接点之下

260
00:10:03,000 --> 00:10:05,320
找到你这个文件系统的根

261
00:10:05,360 --> 00:10:06,720
从这个地方再往下找

262
00:10:06,760 --> 00:10:08,840
就可以找到 当前这个

263
00:10:08,880 --> 00:10:10,640
已挂接文件系统当中的

264
00:10:10,680 --> 00:10:12,440
任何一个文件了

265
00:10:12,480 --> 00:10:15,760
接下来我们说文件系统的种类

266
00:10:15,800 --> 00:10:17,440
我们最常用一种文件系统

267
00:10:17,480 --> 00:10:18,840
叫磁盘文件系统

268
00:10:18,880 --> 00:10:21,280
它是用磁盘作为存储介质

269
00:10:21,320 --> 00:10:23,000
在上面来存数据的

270
00:10:23,040 --> 00:10:27,040
这上头我们定义了各种各样的文件系统

271
00:10:27,080 --> 00:10:28,160
这时候会问

272
00:10:28,200 --> 00:10:30,160
为啥我会定义这么多种文件系统

273
00:10:30,200 --> 00:10:31,880
我有一种是不是就够用了

274
00:10:31,920 --> 00:10:32,960
不是这样的

275
00:10:33,000 --> 00:10:36,840
不同的文件系统由于存的数据不同

276
00:10:36,880 --> 00:10:38,960
它会做不同优化

277
00:10:39,000 --> 00:10:40,520
它使用场景的不同

278
00:10:40,560 --> 00:10:42,880
它也会做各自不同的优化

279
00:10:42,920 --> 00:10:44,960
比如说像我们的光盘

280
00:10:45,000 --> 00:10:46,160
它的文件系统呢

281
00:10:46,200 --> 00:10:48,040
它是一次性写入 多次读出

282
00:10:48,080 --> 00:10:49,960
而正常磁盘文件系统呢

283
00:10:50,000 --> 00:10:52,880
它是多次读入写出的 会有修改

284
00:10:52,920 --> 00:10:55,560
这样的话 它的优化角度是会不一样的

285
00:10:55,600 --> 00:10:58,680
不同的文件系统它的安全要求不同

286
00:10:58,720 --> 00:11:00,120
安全要求级别越高

287
00:11:00,160 --> 00:11:02,040
它的访问效率也会相对下降

288
00:11:02,080 --> 00:11:04,720
对于我要求安全级别不高的文件系统

289
00:11:04,760 --> 00:11:08,360
我可能就把安全机制减弱 甚至于取消

290
00:11:08,400 --> 00:11:12,320
这样我们就构成了很多种不同文件系统

291
00:11:12,360 --> 00:11:13,440
这是一类

292
00:11:13,480 --> 00:11:16,200
再有一类是数据库文件系统

293
00:11:16,240 --> 00:11:18,720
它可以基于文件特征

294
00:11:18,760 --> 00:11:21,360
来被寻址或者是被检索

295
00:11:21,400 --> 00:11:24,720
一个例子呢就是winFS

296
00:11:24,760 --> 00:11:27,440
再有一个呢是日志文件系统

297
00:11:27,480 --> 00:11:30,080
也就说我们对文件系统的修改

298
00:11:30,120 --> 00:11:32,920
这些我必须以原子的形式来进行

299
00:11:32,960 --> 00:11:34,720
因为我的数据很关键

300
00:11:34,760 --> 00:11:37,800
比如说我银行里的这些记录的修改

301
00:11:37,840 --> 00:11:40,880
这时候我们构成日志文件系统

302
00:11:40,920 --> 00:11:43,200
它是指文件系统上 所有修改

303
00:11:43,240 --> 00:11:45,120
它都会做相应的记录

304
00:11:45,160 --> 00:11:48,360
以避免我这个操作执行到半截

305
00:11:48,400 --> 00:11:50,680
所导致文件系统损坏

306
00:11:50,720 --> 00:11:54,000
由此导致数据丢失

307
00:11:54,040 --> 00:11:55,920
网络分布式文件系统

308
00:11:55,960 --> 00:11:57,080
这时候实际上相当于

309
00:11:57,120 --> 00:12:01,400
我们看到的是把文件存到远端的机器上

310
00:12:01,440 --> 00:12:03,880
这时候呢不同的网络访问方式

311
00:12:03,920 --> 00:12:06,760
构成了我们这里不同的文件系统

312
00:12:06,800 --> 00:12:09,480
再有一个呢是特殊文件系统

313
00:12:09,520 --> 00:12:11,280
比如说像我们前面讲到的

314
00:12:11,320 --> 00:12:14,040
进程间通讯当中用到的管道

315
00:12:14,080 --> 00:12:17,360
就是一类特殊的文件系统

316
00:12:17,400 --> 00:12:18,600
对于分布式文件系统

317
00:12:18,640 --> 00:12:20,440
我们还想多说两句

318
00:12:20,480 --> 00:12:23,160
也就说我们在这里为了进行共享

319
00:12:23,200 --> 00:12:24,840
前面的文件共享呢

320
00:12:24,880 --> 00:12:27,480
是在一个系统里多个进程之间

321
00:12:27,520 --> 00:12:28,760
分布式文件系统呢

322
00:12:28,800 --> 00:12:32,360
它是想通过网络来进行文件共享

323
00:12:32,400 --> 00:12:35,160
文件被存到远端的服务器上

324
00:12:35,200 --> 00:12:36,960
对于这种情况

325
00:12:37,000 --> 00:12:40,920
我们用户在访问远端文件系统的时候呢

326
00:12:40,960 --> 00:12:44,840
要通过挂接远端服务器上的文件

327
00:12:44,880 --> 00:12:48,160
这时候就会导致其中有网络通讯

328
00:12:48,200 --> 00:12:50,640
我们正常的标准的文件操作

329
00:12:50,680 --> 00:12:54,480
就会转换成网络上远程访问

330
00:12:54,520 --> 00:12:56,400
在这种情况下 我们在这里呢

331
00:12:56,440 --> 00:13:00,320
存在多种分布式文件系统的共享协议

332
00:13:00,360 --> 00:13:02,480
NFS CIFS

333
00:13:02,520 --> 00:13:04,760
这是Unix和windows常用的

334
00:13:04,800 --> 00:13:08,560
两种网络文件系统

335
00:13:08,600 --> 00:13:10,480
对于分布式文件系统

336
00:13:10,520 --> 00:13:12,920
我们会面临比原来更大一些麻烦

337
00:13:12,960 --> 00:13:14,920
你比如说对于安全 

338
00:13:14,960 --> 00:13:18,000
在本地呢我只需要标识这个用户是谁

339
00:13:18,040 --> 00:13:19,000
我能标识清楚

340
00:13:19,040 --> 00:13:21,720
这个安全的管理就可以实施了

341
00:13:21,760 --> 00:13:24,640
而在网络环境上你想识别一个用户

342
00:13:24,680 --> 00:13:26,480
这时候它会变得更复杂

343
00:13:26,520 --> 00:13:27,480
所以在这种情况下

344
00:13:27,520 --> 00:13:29,240
我们用到的NFS

345
00:13:29,280 --> 00:13:32,200
实际上它是存在某些安全隐患的

346
00:13:32,240 --> 00:13:34,680
再有一个问题呢 是一致性问题

347
00:13:34,720 --> 00:13:36,880
加了网络之后 我读写的时候

348
00:13:36,920 --> 00:13:39,960
这个一致性就更难把握了

349
00:13:40,000 --> 00:13:41,200
出了错误之后

350
00:13:41,240 --> 00:13:44,600
我的错误处理呢也会比原来更复杂

351
00:13:44,640 --> 00:13:48,040
这都是广域网上的  或者网络上的

352
00:13:48,080 --> 00:13:52,200
分布式文件系统所面临的挑战

353
00:13:52,240 --> 00:13:53,880
到这儿呢 我们就对

354
00:13:53,920 --> 00:13:55,880
文件系统的基本概念呢

355
00:13:55,920 --> 00:13:58,360
有了一个大致的介绍

356
00:13:58,400 --> 00:13:58,760


357
00:13:58,800 --> 00:13:59,200


358
00:13:59,240 --> 00:13:59,280