1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] NATE哈迪森：当你有多个程序打开一个

2
00:00:09,360 --> 00:00:11,250
计算机，它似乎是一切的

3
00:00:11,250 --> 00:00:12,880
在同一时间运行。

4
00:00:12,880 --> 00:00:15,350
例如，您可能会在Web浏览器，如

5
00:00:15,350 --> 00:00:19,360
Firefox或Internet Explorer，在iTunes上听音乐，

6
00:00:19,360 --> 00:00:21,490
用Word写文章。

7
00:00:21,490 --> 00:00:24,240
然而，引擎盖下，该方案

8
00:00:24,240 --> 00:00:25,830
在同一时间，运行一个。

9
00:00:25,830 --> 00:00:29,750
这是工作的操作系统，在Windows，Mac OSX，

10
00:00:29,750 --> 00:00:33,070
Linux中，每一个单独的进程管理，作为

11
00:00:33,070 --> 00:00:35,900
程序是已知的，它们之间切换，所以，当你

12
00:00:35,900 --> 00:00:38,610
去检查你的Facebook页面，你的文章

13
00:00:38,610 --> 00:00:41,590
再次，Word是一个。

14
00:00:41,590 --> 00:00:44,890
>> 但是，有时候，我们希望自己能够

15
00:00:44,890 --> 00:00:47,440
做多这样的事情，太。

16
00:00:47,440 --> 00:00:49,630
如果你像我一样，你可能有一堆

17
00:00:49,630 --> 00:00:52,730
不同的选项卡中打开您的网页浏览器，一个用于电子邮件，

18
00:00:52,730 --> 00:00:55,070
一个带有日历，等等。

19
00:00:55,070 --> 00:00:58,270
我们可以把每一个标签作为一个单独的程序或进程，

20
00:00:58,270 --> 00:01:01,300
像谷歌Chrome浏览器，但许多程序都使用了

21
00:01:01,300 --> 00:01:04,430
重量更轻版本的过程称为一个线程。

22
00:01:04,430 --> 00:01:07,190
>> 线程是另一个单位的处理，一组

23
00:01:07,190 --> 00:01:10,100
指令或者程序代码，可以在“运行”，报价引文结束，

24
00:01:10,100 --> 00:01:12,560
同时，其他的线程。

25
00:01:12,560 --> 00:01:15,150
这是什么使得它可以为你浏览Facebook

26
00:01:15,150 --> 00:01:17,940
一边听我在背景中，或有两个

27
00:01:17,940 --> 00:01:20,790
YouTube视频同时播放。

28
00:01:20,790 --> 00:01:24,660
所以，一般的话题，被称为并发，通常

29
00:01:24,660 --> 00:01:26,930
不来这么早起来的计算机科学课程

30
00:01:26,930 --> 00:01:29,790
因为较低层次的细节需要讨论

31
00:01:29,790 --> 00:01:31,930
操作系统和等。

32
00:01:31,930 --> 00:01:34,170
但是，我们在使用的编程语言

33
00:01:34,170 --> 00:01:38,000
CS50，开始刮，提供了一些极好的工具，

34
00:01:38,000 --> 00:01:40,390
可以更容易地编写程序时，多重的东西

35
00:01:40,390 --> 00:01:42,390
在一次。

36
00:01:42,390 --> 00:01:45,050
>> 当你建立临时的程序，你不断

37
00:01:45,050 --> 00:01:46,760
工作线程。

38
00:01:46,760 --> 00:01:49,770
每刮脚本，这是一个代码块，开始

39
00:01:49,770 --> 00:01:52,600
“当”拼图之一的，可以被认为是

40
00:01:52,600 --> 00:01:54,380
作为一个单独的线程。

41
00:01:54,380 --> 00:01:58,040
让我们来看看一个简单的划痕程序，看它是如何工作的。

42
00:01:58,040 --> 00:02:01,730
>> 在这里，我们已经得到了一条鱼的物体，或精灵，有两个脚本

43
00:02:01,730 --> 00:02:05,000
都开始当我们点击绿色的小国旗按钮。

44
00:02:05,000 --> 00:02:07,290
第一个脚本控制的鱼类的议案。

45
00:02:07,290 --> 00:02:09,850
当绿旗后，鱼被放入

46
00:02:09,850 --> 00:02:12,450
在屏幕的左侧，称为阶段，

47
00:02:12,450 --> 00:02:14,090
朝向右侧。

48
00:02:14,090 --> 00:02:17,070
然后，在一组指令，将永远运行下去，直到我们

49
00:02:17,070 --> 00:02:20,270
停止该程序，的鱼滑行到右侧，

50
00:02:20,270 --> 00:02:22,900
转了一圈，又回到的左侧，

51
00:02:22,900 --> 00:02:24,470
再转身。

52
00:02:24,470 --> 00:02:27,410
第二个脚本控制鱼的思维过程。

53
00:02:27,410 --> 00:02:29,290
事实证明，这是一个饥饿的鱼。

54
00:02:29,290 --> 00:02:32,080
因此，等待3秒后，鱼会认为，

55
00:02:32,080 --> 00:02:34,420
“我饿了，”四分之一秒。

56
00:02:34,420 --> 00:02:36,440
这个脚本也将永远运行下去。

57
00:02:36,440 --> 00:02:38,940
正如我们所看到，运行该程序通过点击

58
00:02:38,940 --> 00:02:41,730
绿色标志，这两个脚本执行

59
00:02:41,730 --> 00:02:43,100
同时进行。

60
00:02:43,100 --> 00:02:46,460
鱼移动，并认为在相同的时间。

61
00:02:46,460 --> 00:02:49,030
>> 由于穷人的鱼看起来太饿了，让我们添加一些

62
00:02:49,030 --> 00:02:50,670
俊俏的泡芙吃。

63
00:02:50,670 --> 00:02:53,060
希望它们不会在水中崩解。

64
00:02:53,060 --> 00:02:55,560
当我们在第二个精灵，我们还可以

65
00:02:55,560 --> 00:02:58,020
添加脚本，雪碧。

66
00:02:58,020 --> 00:02:59,580
，因此，可以通过另一组

67
00:02:59,580 --> 00:03:00,830
将运行的线程的。

68
00:03:03,590 --> 00:03:06,270
为了让我们的计划控制的用户时，

69
00:03:06,270 --> 00:03:09,340
饥饿的鱼得到的食物，让我们说，只要空间

70
00:03:09,340 --> 00:03:11,840
酒吧被击中，干酪泡芙出现在舞台上的

71
00:03:11,840 --> 00:03:13,300
鱼可吃。

72
00:03:13,300 --> 00:03:15,760
在我们按下空格键，我们将要保留的俗气

73
00:03:15,760 --> 00:03:19,020
喷隐藏，使鱼无法看到它们。

74
00:03:19,020 --> 00:03:21,140
要做到这一点，我们需要一对夫妇的脚本

75
00:03:21,140 --> 00:03:22,750
俗气喷精灵。

76
00:03:22,750 --> 00:03:26,980
第一个脚本，绿色标志，只是隐藏的食物。

77
00:03:26,980 --> 00:03:29,530
不同于其他脚本，我们已经写了，这一次将不会保留

78
00:03:29,530 --> 00:03:30,560
运行下去。

79
00:03:30,560 --> 00:03:33,250
它非常迅速地开始和结束，权当我们点击

80
00:03:33,250 --> 00:03:35,000
绿色环保标志的按钮。

81
00:03:35,000 --> 00:03:37,180
>> 我们将等待下一个脚本的空间酒吧

82
00:03:37,180 --> 00:03:39,590
压，然后再执行。

83
00:03:39,590 --> 00:03:42,770
我们可以通过调用等待用户输入的“等待”或“监听”

84
00:03:42,770 --> 00:03:43,860
一个事件。

85
00:03:43,860 --> 00:03:46,750
而当接收到一个事件或执行的代码

86
00:03:46,750 --> 00:03:50,280
听说是被称为事件处理代码。

87
00:03:50,280 --> 00:03:53,550
我们的空间酒吧事件处理程序将显示俗气喷

88
00:03:53,550 --> 00:03:56,330
在屏幕上，使鱼可以吃。

89
00:03:56,330 --> 00:03:58,880
在这一点上，一切都看起来很不错。

90
00:03:58,880 --> 00:04:00,990
>> 接下来的事情，我们需要做的是要弄清楚如何获得

91
00:04:00,990 --> 00:04:03,570
认识到，有食物吃的鱼。

92
00:04:03,570 --> 00:04:06,030
让我们添加另一个线程来的鱼不断

93
00:04:06,030 --> 00:04:08,790
检查是否接触俗气喷。

94
00:04:08,790 --> 00:04:11,510
我们这样做，因为这样我们就可以在一个单独的线程

95
00:04:11,510 --> 00:04:13,710
经常检查食品。

96
00:04:13,710 --> 00:04:16,829
否则，我们就只能够定期检查食品

97
00:04:16,829 --> 00:04:21,180
之间滑翔，转身，等待，​​或思考。

98
00:04:21,180 --> 00:04:22,000
>> OK。

99
00:04:22,000 --> 00:04:23,785
现在，让我们从头程序的运行。

100
00:04:23,785 --> 00:04:26,921
正如所料，食品立即隐藏和

101
00:04:26,921 --> 00:04:28,920
饥饿的鱼游，来回像以前一样。

102
00:04:32,050 --> 00:04:35,060
当我们按​​下空格键，映入眼帘的俗气喷，

103
00:04:35,060 --> 00:04:37,470
饥饿的鱼说：哇。

104
00:04:37,470 --> 00:04:39,340
但是别急，这是怪异的。

105
00:04:39,340 --> 00:04:42,150
怎么来的鱼的“我饿了”的思想中断

106
00:04:42,150 --> 00:04:43,580
其他的东西？

107
00:04:43,580 --> 00:04:45,780
这是因为我们没有建立任何协调

108
00:04:45,780 --> 00:04:47,590
之间的鱼类脚本。

109
00:04:47,590 --> 00:04:50,610
每个运行在它自己的线程中，忘却什么

110
00:04:50,610 --> 00:04:52,120
别人在做什么。

111
00:04:52,120 --> 00:04:54,980
让我们来解决这个问题之前，我们前进。

112
00:04:54,980 --> 00:04:57,700
>> 线程之间的协调是一个棘手的任务，因为我们

113
00:04:57,700 --> 00:05:00,940
没有明确的控制，每个线程运行时或

114
00:05:00,940 --> 00:05:02,190
不运行。

115
00:05:02,190 --> 00:05:04,710
从一个线程发送消息到另一个，我们需要

116
00:05:04,710 --> 00:05:08,300
在一个线程中使用一个变量，我们可以设置，或写，

117
00:05:08,300 --> 00:05:10,170
和读取在其他。

118
00:05:10,170 --> 00:05:12,920
让我们创建一个变量称为foodFound的，我们可以设置

119
00:05:12,920 --> 00:05:15,530
真正运行时，鱼到俗气喷。

120
00:05:15,530 --> 00:05:17,540
好了，当然，我们要确保，我们将它设置为

121
00:05:17,540 --> 00:05:19,240
假最初。

122
00:05:19,240 --> 00:05:22,540
然后，在鱼的思想线程的，我们将检查，看看是否

123
00:05:22,540 --> 00:05:25,400
鱼食品后，才显示“我饿了”

124
00:05:25,400 --> 00:05:26,770
认为泡沫。

125
00:05:26,770 --> 00:05:29,670
>> 现在，再次运行程序，我们看到的鱼

126
00:05:29,670 --> 00:05:31,580
不被打断的想法饥饿时，

127
00:05:31,580 --> 00:05:33,820
俗气喷都出来了。

128
00:05:33,820 --> 00:05:36,820
我们的最后一个问题是，不俗气喷

129
00:05:36,820 --> 00:05:39,800
离开后，鱼，报价引文结束，“吃”。

130
00:05:39,800 --> 00:05:42,305
从鱼的脚本，有没有简单的方法来隐藏的俗气

131
00:05:42,305 --> 00:05:44,710
泡芙，所以我们需要将消息发送到的俗气喷

132
00:05:44,710 --> 00:05:46,780
精灵可以隐藏自身。

133
00:05:46,780 --> 00:05:49,550
我们可以做到这一点与另一个变量的俗气喷

134
00:05:49,550 --> 00:05:52,680
子画面有访问，以及鱼的子画面。

135
00:05:52,680 --> 00:05:55,720
>> 然而，在这种情况下，一个干净的方式来做到这一点，

136
00:05:55,720 --> 00:05:57,840
，自而不是将消息发送到一个脚本，

137
00:05:57,840 --> 00:06:00,570
在执行的中间的某个地方，我们可以发送

138
00:06:00,570 --> 00:06:03,710
消息发送到一个脚本，等待开始。

139
00:06:03,710 --> 00:06:07,360
我们做到这一点的鱼事件，我们将播出

140
00:06:07,360 --> 00:06:08,800
呼叫吃掉了。

141
00:06:08,800 --> 00:06:11,510
然后，我们将创建一个脚本的俗气泡芙，

142
00:06:11,510 --> 00:06:13,030
等待此事件。

143
00:06:13,030 --> 00:06:15,560
这是一个类似的空格键事件，除了这个

144
00:06:15,560 --> 00:06:19,250
时间后，用户不是一个直接触发事件。

145
00:06:19,250 --> 00:06:22,800
现在我们要做的是设置我们的foodFound的变量回

146
00:06:22,800 --> 00:06:25,750
为false，我们现在可以给许多饥饿的鱼

147
00:06:25,750 --> 00:06:28,470
份俗气喷，因为它要。

148
00:06:28,470 --> 00:06:30,040
>> 所以不要太糟糕了，对不对？

149
00:06:30,040 --> 00:06:33,400
在C语言中，编写多线程程序是比较复杂的，

150
00:06:33,400 --> 00:06:35,700
但基本是相同的。

151
00:06:35,700 --> 00:06:38,690
无论如何，我希望你有一个伟大的时间来建立一些有趣的

152
00:06:38,690 --> 00:06:41,030
在Scratch的并发程序。

153
00:06:41,030 --> 00:06:42,570
我的名字是Nate哈迪森。

154
00:06:42,570 --> 00:06:45,260
这是CS50。