﻿1
00:00:01,190 --> 00:00:02,840
‫Jonas: Lassen Sie uns

2
00:00:02,840 --> 00:00:05,520
‫jetzt etwas Code schreiben, um ein besseres Verständnis

3
00:00:05,520 --> 00:00:07,893
‫davon zu bekommen, was in der Ereignisschleife passiert.

4
00:00:09,200 --> 00:00:11,370
‫Um mit dem Codierungsteil

5
00:00:11,370 --> 00:00:13,670
‫dieses Abschnitts zu beginnen, holen Sie

6
00:00:13,670 --> 00:00:15,970
‫sich also wie zuvor die Startdateien

7
00:00:15,970 --> 00:00:18,550
‫für diesen Abschnitt, kopieren Sie sie irgendwo

8
00:00:18,550 --> 00:00:22,050
‫und öffnen Sie dann das Projekt in Ihrem Code-Editor.

9
00:00:22,050 --> 00:00:24,310
‫Also habe ich es hier auf dem

10
00:00:24,310 --> 00:00:27,550
‫Desktop und in meinem VSCode, und alles, was wir hier zum

11
00:00:27,550 --> 00:00:31,420
‫Starten haben, ist diese Testdatei. txt, also erstelle ich hier eine neue

12
00:00:31,420 --> 00:00:35,033
‫Datei und nenne sie die Ereignisschleife. js.

13
00:00:38,040 --> 00:00:41,530
‫Okay, jetzt ist es tatsächlich extrem schwierig, die Ereignisschleife

14
00:00:41,530 --> 00:00:44,000
‫richtig zu simulieren, weil wir nicht

15
00:00:44,000 --> 00:00:46,400
‫wirklich viele Rückrufe gleichzeitig in

16
00:00:46,400 --> 00:00:48,080
‫alle Rückrufwarteschlangen stellen

17
00:00:48,080 --> 00:00:51,260
‫können, über die wir zuvor gesprochen haben, oder.

18
00:00:51,260 --> 00:00:53,710
‫Diese Situation tritt auf, wenn

19
00:00:53,710 --> 00:00:56,360
‫beispielsweise viele Anfragen in Ihre App

20
00:00:56,360 --> 00:01:00,240
‫eingehen, aber hier lokal nur sehr schwer zu replizieren.

21
00:01:00,240 --> 00:01:03,150
‫Aber wir werden trotzdem einige sehr interessante Experimente

22
00:01:03,150 --> 00:01:05,390
‫mit einigen der Dinge machen, die wir

23
00:01:05,390 --> 00:01:07,540
‫im letzten Video gelernt haben.

24
00:01:07,540 --> 00:01:09,830
‫Und was wir tun werden, ist,

25
00:01:09,830 --> 00:01:12,190
‫eine Reihe von Codezeilen zu schreiben und

26
00:01:12,190 --> 00:01:15,130
‫dann herauszufinden, in welcher Reihenfolge sie in der Ereignisschleife

27
00:01:15,130 --> 00:01:17,950
‫ausgeführt werden sollten, und zu analysieren, ob die

28
00:01:17,950 --> 00:01:20,360
‫Ergebnisse, die wir erhalten, tatsächlich Sinn machen.

29
00:01:20,360 --> 00:01:22,710
‫Beginnen wir also damit, setTimeout zu schreiben,

30
00:01:24,290 --> 00:01:26,513
‫also im Grunde, um einen Timer

31
00:01:27,980 --> 00:01:29,890
‫zu setzen, und ich verwende

32
00:01:29,890 --> 00:01:31,270
‫hier eine Pfeilfunktion,

33
00:01:31,270 --> 00:01:33,773
‫und das einzige, was ich tun werde,

34
00:01:34,930 --> 00:01:39,930
‫ist, einen String zu loggen, also Konsole. log, Timer eins ist abgelaufen,

35
00:01:41,800 --> 00:01:45,390
‫und ich möchte, dass dieser nach null Sekunden abläuft.

36
00:01:45,390 --> 00:01:47,740
‫Okay, speichern Sie es, und dann sehen

37
00:01:47,740 --> 00:01:50,030
‫Sie, dass diese Zeichenfolge hier tatsächlich korrigiert

38
00:01:50,030 --> 00:01:53,120
‫wurde, also diese Anführungszeichen geändert und das Semikolon hinzugefügt wurde,

39
00:01:53,120 --> 00:01:54,810
‫und das liegt an

40
00:01:54,810 --> 00:01:56,940
‫der Prettier-Erweiterung, die wir zuvor installiert haben.

41
00:01:56,940 --> 00:01:58,510
‫Jetzt werde ich es hier nicht

42
00:01:58,510 --> 00:01:59,850
‫konfigurieren, denn für dieses

43
00:01:59,850 --> 00:02:02,050
‫kleine Beispiel ist das nicht wirklich notwendig, okay.

44
00:02:02,050 --> 00:02:05,150
‫Das ist also das Einstellen eines Timers, dann

45
00:02:05,150 --> 00:02:09,320
‫verwenden wir auch setImmediate, also merken Sie sich das aus dem letzten Video.

46
00:02:09,320 --> 00:02:11,620
‫Okay, jetzt werde ich hier nicht viel erklären,

47
00:02:11,620 --> 00:02:13,350
‫denn jetzt lass uns diesen

48
00:02:13,350 --> 00:02:15,510
‫Code schreiben und dann analysieren, was passiert, okay.

49
00:02:15,510 --> 00:02:20,320
‫Also setImmediate, und genau wie der andere Timer erhält

50
00:02:20,320 --> 00:02:22,500
‫er eine Callback-Funktion.

51
00:02:22,500 --> 00:02:25,130
‫Und alles, was wir tun werden, ist,

52
00:02:27,720 --> 00:02:31,440
‫sofort ein fertiges zu schreiben, und dieses hat keine Zeit,

53
00:02:31,440 --> 00:02:33,520
‫weil es nicht notwendig

54
00:02:33,520 --> 00:02:36,930
‫ist, weil es, wie der Name sagt, sofort ist.

55
00:02:36,930 --> 00:02:38,540
‫Eine andere Sache, die wir

56
00:02:38,540 --> 00:02:41,620
‫tun möchten, ist, diese Datei hier zu lesen

57
00:02:41,620 --> 00:02:44,930
‫und dann eine Callback-Funktion zu übergeben, okay, also als

58
00:02:44,930 --> 00:02:48,963
‫erstes müssen wir das richtige Modul benötigen, also FS und jetzt

59
00:02:52,600 --> 00:02:54,987
‫fs. readFile, und wir wollen text-file. txt,

60
00:03:05,586 --> 00:03:08,003
‫und dann passiert etwas.

61
00:03:09,270 --> 00:03:12,153
‫Und genau wie zuvor, sagen wir

62
00:03:13,740 --> 00:03:17,263
‫hier einfach, in diesem Fall I/O beendet, in Ordnung.

63
00:03:18,830 --> 00:03:21,170
‫Also I/O, weil dieser Callback

64
00:03:21,170 --> 00:03:24,830
‫hier eigentlich mit einer I/O-Aufgabe zusammenhängt, die tatsächlich

65
00:03:24,830 --> 00:03:28,440
‫ihre eigene Phase in der Ereignisschleife bekommt, richtig.

66
00:03:28,440 --> 00:03:31,930
‫Und schließlich fügen wir einfach eine Konsole hinzu. Melden Sie sich

67
00:03:31,930 --> 00:03:35,473
‫hier an und sagen Sie gut, hallo vom Top-Level-Code.

68
00:03:37,517 --> 00:03:40,440
‫Okay, also Top-Level-Code, denn er ist tatsächlich der einzige,

69
00:03:40,440 --> 00:03:43,130
‫der nicht in einem Callback enthalten ist.

70
00:03:43,130 --> 00:03:46,000
‫Lassen Sie uns in diesem sehr kleinen Beispiel, das wir

71
00:03:46,000 --> 00:03:48,400
‫jetzt haben, versuchen herauszufinden, was zuerst passieren sollte.

72
00:03:48,400 --> 00:03:50,510
‫Denken Sie daran, dass der erste Schritt

73
00:03:50,510 --> 00:03:53,310
‫beim Laden eines Moduls darin besteht, dass der Code

74
00:03:53,310 --> 00:03:56,000
‫der obersten Ebene ausgeführt wird, also sollten wir

75
00:03:56,000 --> 00:03:59,360
‫sofort diese Konsole sehen. log hier, richtig, erst

76
00:03:59,360 --> 00:04:02,110
‫später sollten wir die anderen Protokolle sehen, die

77
00:04:02,110 --> 00:04:04,280
‫von diesen anderen Rückrufen stammen, da

78
00:04:04,280 --> 00:04:06,820
‫diese Rückrufe tatsächlich in der Ereignisschleife ausgeführt werden.

79
00:04:06,820 --> 00:04:09,190
‫Versuchen wir also zu sehen, ob das tatsächlich der

80
00:04:09,190 --> 00:04:12,000
‫Fall ist, und analysieren wir es dann sogar noch ein bisschen.

81
00:04:12,000 --> 00:04:15,150
‫Also öffne die Konsole hier und wieder mache

82
00:04:15,150 --> 00:04:17,250
‫ich das mit dem

83
00:04:17,250 --> 00:04:22,023
‫Terminal, oder tatsächlich in der Ansicht, also dieses Terminal hier, in Ordnung.

84
00:04:23,100 --> 00:04:27,020
‫Beachten Sie also die Ereignisschleife. js, oder bevor wir

85
00:04:27,020 --> 00:04:30,960
‫dies tun, muss ich diesen Tippfehler hier korrigieren, also

86
00:04:30,960 --> 00:04:33,580
‫ist es eine Testdatei, keine Textdatei.

87
00:04:33,580 --> 00:04:36,093
‫Okay, aber jetzt sind wir bereit, diesen

88
00:04:36,960 --> 00:04:40,320
‫Befehl auszuführen, und die Ergebnisse sind da, also ist das

89
00:04:40,320 --> 00:04:43,810
‫erste Protokoll, das wir hier haben, hallo vom Code der obersten

90
00:04:43,810 --> 00:04:46,100
‫Ebene, und das wurde erwartet, richtig,

91
00:04:46,100 --> 00:04:49,390
‫denn dies ist ein Code, der ausgeführt wird sofort.

92
00:04:49,390 --> 00:04:52,940
‫Danach haben wir diese drei Ausgaben, aber sie sind

93
00:04:52,940 --> 00:04:55,460
‫eigentlich in keiner bestimmten Reihenfolge, und

94
00:04:55,460 --> 00:04:57,640
‫das liegt daran, dass dieser

95
00:04:57,640 --> 00:05:00,970
‫Code hier, also dieser Code, tatsächlich nicht in einem

96
00:05:00,970 --> 00:05:03,780
‫E/A-Zyklus ist, also nicht innerhalb der Ereignisschleife

97
00:05:03,780 --> 00:05:07,170
‫läuft. weil es nicht innerhalb einer Rückruffunktion ausgeführt wird.

98
00:05:07,170 --> 00:05:10,370
‫Okay, auf Ihrem Computer sehen Sie dieses Protokoll möglicherweise tatsächlich

99
00:05:11,470 --> 00:05:13,160
‫vor diesem, und dann

100
00:05:13,160 --> 00:05:15,360
‫ist dieses hier nur das letzte,

101
00:05:15,360 --> 00:05:18,550
‫da das Lesen dieser großen Datei hier einige Zeit

102
00:05:18,550 --> 00:05:20,840
‫in Anspruch nimmt und es daher wahrscheinlich

103
00:05:20,840 --> 00:05:23,060
‫immer das letzte sein wird eins.

104
00:05:23,060 --> 00:05:27,140
‫Auch hier hat die Reihenfolge dieser drei hier noch einmal nichts

105
00:05:27,140 --> 00:05:29,640
‫mit der Ereignisschleife zu tun, da

106
00:05:29,640 --> 00:05:31,320
‫sie tatsächlich noch nicht

107
00:05:31,320 --> 00:05:33,420
‫in der Ereignisschleife ausgeführt werden.

108
00:05:33,420 --> 00:05:36,490
‫Dazu müssen wir sie oder

109
00:05:36,490 --> 00:05:40,490
‫zumindest diese beiden hier in eine Callback-Funktion verschieben.

110
00:05:40,490 --> 00:05:43,713
‫Und dafür werden wir diesen hier tatsächlich verwenden.

111
00:05:45,270 --> 00:05:50,190
‫Also lass es mich hier setzen und sagen Timer zwei und Timer zwei

112
00:05:50,190 --> 00:05:55,190
‫hier oder sofort zwei, und ich werde auch einen weiteren Timer hier hinzufügen, also

113
00:05:55,270 --> 00:05:57,740
‫Timer drei, und dieser wird drei

114
00:05:57,740 --> 00:06:01,140
‫Sekunden lang laufen, das sind also 3000 Millisekunden .

115
00:06:01,140 --> 00:06:03,840
‫Lassen Sie uns nun das Ergebnis von diesem versuchen.

116
00:06:03,840 --> 00:06:06,230
‫Aber bevor wir das tun,

117
00:06:06,230 --> 00:06:09,660
‫überlegen wir uns, warum das Programm nach dem Ausführen

118
00:06:09,660 --> 00:06:13,730
‫des gesamten Codes zuvor beendet wurde und zur Eingabeaufforderung hier zurückkehrte.

119
00:06:13,730 --> 00:06:16,500
‫Denken Sie also daran, wie Node. js entscheidet, ob es

120
00:06:16,500 --> 00:06:19,000
‫die Ereignisschleife weiter ausführen soll, naja, es tut

121
00:06:19,000 --> 00:06:21,620
‫dies, indem es fragt, ob noch Zeit im Hintergrund

122
00:06:21,620 --> 00:06:24,580
‫läuft, und wenn ja, wird es nicht beendet, und wenn

123
00:06:24,580 --> 00:06:26,800
‫es noch einen ausstehenden Timer gibt, dann

124
00:06:26,800 --> 00:06:29,140
‫ist es das nicht werde das Programm verlassen.

125
00:06:29,140 --> 00:06:30,920
‫Aber wenn nicht, was im

126
00:06:30,920 --> 00:06:33,920
‫ersten Beispiel hier der Fall war, dann beendet es

127
00:06:33,920 --> 00:06:36,660
‫das Programm sofort, okay, aber jetzt haben wir

128
00:06:36,660 --> 00:06:38,980
‫hier tatsächlich einen Timer, also läuft dieser

129
00:06:38,980 --> 00:06:41,620
‫drei Sekunden lang, und so versuchen wir herauszufinden,

130
00:06:41,620 --> 00:06:43,220
‫was passiert hier.

131
00:06:45,260 --> 00:06:47,450
‫Okay, Sie sehen, dass es

132
00:06:47,450 --> 00:06:50,640
‫nicht beendet wird, und erst jetzt, nachdem Timer drei

133
00:06:50,640 --> 00:06:53,170
‫abgelaufen ist, hat es die Anwendung beendet.

134
00:06:53,170 --> 00:06:56,100
‫Okay, sehen wir uns das noch einmal

135
00:06:56,100 --> 00:06:59,480
‫an, also alle diese Log-Timer laufen, der Timer ist

136
00:06:59,480 --> 00:07:02,070
‫beendet und die Anwendung wurde beendet.

137
00:07:02,070 --> 00:07:04,490
‫Nun zu diesen Ergebnissen hier, lassen

138
00:07:04,490 --> 00:07:06,820
‫Sie uns dies hier etwas

139
00:07:06,820 --> 00:07:10,113
‫einfacher machen und hier nur ein kleines Trennzeichen hinzufügen.

140
00:07:11,360 --> 00:07:14,683
‫Okay, mach das sauber, okay.

141
00:07:16,510 --> 00:07:19,600
‫Diese vier hier sind also die Ausgaben, die

142
00:07:19,600 --> 00:07:22,110
‫nicht wirklich in der Ereignisschleife ausgeführt wurden,

143
00:07:22,110 --> 00:07:24,380
‫aber diese drei hier kamen

144
00:07:24,380 --> 00:07:28,150
‫tatsächlich aus der Ereignisschleife. Lassen Sie uns nun diese Ergebnisse analysieren.

145
00:07:28,150 --> 00:07:29,980
‫Wenn Sie sich

146
00:07:29,980 --> 00:07:32,690
‫jetzt an das Diagramm aus der vorherigen

147
00:07:32,690 --> 00:07:36,960
‫Vorlesung erinnern, werden Sie wahrscheinlich gedacht haben, dass der Timer, hier

148
00:07:36,960 --> 00:07:39,640
‫also Timer zwei, eigentlich vor dem

149
00:07:39,640 --> 00:07:42,640
‫setImmediate enden sollte, da er im Diagramm

150
00:07:42,640 --> 00:07:45,100
‫tatsächlich ganz oben auf der Ereignisschleife.

151
00:07:45,100 --> 00:07:48,090
‫Also müssen wir hier timeout mit

152
00:07:48,090 --> 00:07:52,500
‫null setzen, was ungefähr gleich setImmediate sein sollte, richtig.

153
00:07:52,500 --> 00:07:54,610
‫Warum erscheint

154
00:07:54,610 --> 00:07:57,630
‫setImmediate eigentlich vor setTimeout?

155
00:07:57,630 --> 00:08:00,020
‫Nun, es gibt etwas, das ich

156
00:08:00,020 --> 00:08:02,470
‫im letzten Video nicht wirklich erklärt habe, weil

157
00:08:02,470 --> 00:08:05,750
‫ich es nicht noch verwirrender machen wollte, und das ist, dass

158
00:08:05,750 --> 00:08:09,320
‫die Ereignisschleife tatsächlich darauf wartet, dass in der Umfragephase etwas passiert.

159
00:08:09,320 --> 00:08:12,270
‫Also in dieser Phase, in der I/O-Callbacks bearbeitet werden.

160
00:08:12,270 --> 00:08:15,400
‫Wenn also diese Warteschlange von Callbacks leer ist,

161
00:08:15,400 --> 00:08:17,940
‫was in unserem fiktiven Beispiel hier

162
00:08:17,940 --> 00:08:20,270
‫der Fall ist, wir also

163
00:08:20,270 --> 00:08:23,500
‫keine I/O-Callbacks haben, haben wir nur diese Timer, nun,

164
00:08:23,500 --> 00:08:27,490
‫dann wartet die Ereignisschleife in dieser Phase, bis eine abgelaufene Timer.

165
00:08:27,490 --> 00:08:31,430
‫Wenn wir jedoch einen Callback mit setImmediate geplant

166
00:08:31,430 --> 00:08:34,320
‫haben, wird dieser Callback tatsächlich direkt

167
00:08:34,320 --> 00:08:36,920
‫nach der Polling-Phase ausgeführt,

168
00:08:36,920 --> 00:08:40,240
‫und sogar vor abgelaufenen Timern, falls vorhanden.

169
00:08:40,240 --> 00:08:43,270
‫Und in diesem Fall läuft der Timer sofort ab,

170
00:08:43,270 --> 00:08:46,080
‫also nach null Sekunden, aber auch hier

171
00:08:46,080 --> 00:08:49,710
‫wartet die Ereignisschleife tatsächlich, also pausiert sie in der Polling-Phase.

172
00:08:49,710 --> 00:08:52,100
‫Und damit der setImmediate-Callback tatsächlich

173
00:08:52,100 --> 00:08:55,580
‫zuerst ausgeführt wird, ist das der ganze Grund, warum

174
00:08:55,580 --> 00:08:59,730
‫wir dies sofort hier haben, nachdem wir die Timer haben.

175
00:08:59,730 --> 00:09:02,770
‫Okay, und ich weiß, das klingt sehr verwirrend,

176
00:09:02,770 --> 00:09:04,810
‫und ich stimme voll und

177
00:09:04,810 --> 00:09:08,090
‫ganz zu, aber Node. js funktioniert.

178
00:09:08,090 --> 00:09:11,380
‫Und jetzt machen wir das noch ein bisschen verwirrender und

179
00:09:11,380 --> 00:09:14,250
‫fügen den Prozess hinzu. nextTick, über den

180
00:09:14,250 --> 00:09:16,950
‫wir auch in der letzten Vorlesung gesprochen haben.

181
00:09:16,950 --> 00:09:21,950
‫Wir sagen also Prozess. nextTick, und dann übergeben wir ihm

182
00:09:22,170 --> 00:09:24,323
‫wie zuvor einfach eine Callback-Funktion.

183
00:09:25,540 --> 00:09:27,640
‫Und wieder möchte ich mich nur bei

184
00:09:27,640 --> 00:09:31,663
‫der Konsole anmelden und sage Prozess. nextTick.

185
00:09:32,550 --> 00:09:36,150
‫Was denkst du wird also in diesem Fall passieren?

186
00:09:36,150 --> 00:09:40,170
‫Machen Sie eine Vermutung, und sobald Sie bereit sind, können Sie dies

187
00:09:40,170 --> 00:09:42,883
‫ausführen, also lassen Sie uns das tun.

188
00:09:44,120 --> 00:09:48,280
‫Zuerst hier speichern, ausführen und los geht's.

189
00:09:48,280 --> 00:09:51,760
‫Die Ergebnisse sind also wieder drin, und nun

190
00:09:51,760 --> 00:09:55,640
‫war der erste Callback, der ausgeführt wurde, tatsächlich diese Funktion hier.

191
00:09:55,640 --> 00:09:58,220
‫Deshalb haben wir einen Prozess. WeiterHäkchen direkt

192
00:09:58,220 --> 00:09:59,710
‫im ersten an.

193
00:09:59,710 --> 00:10:03,500
‫Warum also war diese Callback-Funktion von process. nextKreuzen Sie die erste

194
00:10:03,500 --> 00:10:06,570
‫von allen an, die ausgeführt werden soll?

195
00:10:06,570 --> 00:10:09,070
‫Denken Sie daran, dass nextTick

196
00:10:09,070 --> 00:10:12,410
‫Teil der Microtasks-Warteschlange ist, die nach jeder

197
00:10:12,410 --> 00:10:16,530
‫Phase ausgeführt wird, also nicht nur nach einem ganzen Tick.

198
00:10:16,530 --> 00:10:19,120
‫Und was hier passiert ist, ist,

199
00:10:19,120 --> 00:10:23,660
‫dass diese Callback-Funktion tatsächlich vor der Phase ausgeführt wurde, in der diese

200
00:10:23,660 --> 00:10:26,970
‫Callback-Funktion hier ausgeführt wurde, und der Phase davor, okay.

201
00:10:26,970 --> 00:10:30,850
‫Nun, nextTick ist eigentlich ein irreführender Name, denn ein

202
00:10:30,850 --> 00:10:33,990
‫Tick ist eigentlich eine ganze Schleife,

203
00:10:33,990 --> 00:10:37,860
‫aber nextTick passiert tatsächlich vor der nächsten Schleifenphase und

204
00:10:37,860 --> 00:10:41,990
‫nicht der gesamte Tick, also habe ich das vorher gesagt.

205
00:10:41,990 --> 00:10:45,830
‫Auf der anderen Seite würde setImmediate Sie denken

206
00:10:45,830 --> 00:10:49,690
‫lassen, dass sein Callback sofort ausgeführt würde, aber

207
00:10:49,690 --> 00:10:52,780
‫das tut es nicht, richtig, also

208
00:10:52,780 --> 00:10:55,570
‫wird setImmediate tatsächlich einmal pro

209
00:10:55,570 --> 00:10:58,800
‫Tick ausgeführt, während nextTick sofort ausgeführt wird.

210
00:10:58,800 --> 00:11:01,820
‫Und so sollten ihre beiden Namen eigentlich vertauscht werden.

211
00:11:01,820 --> 00:11:03,700
‫Sie sollten umgekehrt sein, und dies kann

212
00:11:03,700 --> 00:11:05,390
‫eine Menge Verwirrung stiften, daher

213
00:11:05,390 --> 00:11:08,440
‫ist es am besten, sich immer an eine von ihnen zu halten,

214
00:11:08,440 --> 00:11:12,470
‫und diese ist normalerweise sofort und nicht verarbeiten. nextTick.

215
00:11:12,470 --> 00:11:15,070
‫Wie auch immer, wie ich in einem letzten

216
00:11:15,070 --> 00:11:18,530
‫Video erwähnt habe, sind diese Mechanismen eigentlich eher für ziemlich fortgeschrittene

217
00:11:18,530 --> 00:11:20,320
‫Anwendungsfälle gedacht, weshalb wir sie

218
00:11:20,320 --> 00:11:22,760
‫in unserem Projekt wahrscheinlich nicht verwenden werden.

219
00:11:22,760 --> 00:11:24,970
‫Wenn Sie jedoch mehr darüber

220
00:11:24,970 --> 00:11:28,060
‫erfahren möchten, können Sie jederzeit die offizielle Node-Dokumentation lesen.

221
00:11:28,060 --> 00:11:30,660
‫Okay, damit haben wir einige Aspekte der

222
00:11:30,660 --> 00:11:33,250
‫Event-Schleife simuliert, aber zum Schluss möchte ich

223
00:11:33,250 --> 00:11:35,500
‫noch kurz etwas zum Thread-Pool

224
00:11:35,500 --> 00:11:38,290
‫vorstellen, und dafür werden wir eine komplexere

225
00:11:38,290 --> 00:11:40,950
‫Operation durchführen, die tatsächlich ausgelagert wird den

226
00:11:40,950 --> 00:11:43,490
‫Thread-Pool, und werfen Sie einen Blick

227
00:11:43,490 --> 00:11:47,040
‫darauf, wie lange die Ausführung dieser Vorgänge dauert und

228
00:11:47,040 --> 00:11:48,510
‫wie wir

229
00:11:48,510 --> 00:11:50,870
‫die zuvor besprochene Thread-Pool-Größe ändern können.

230
00:11:50,870 --> 00:11:52,840
‫Wir werden hier also etwas Kryptographie

231
00:11:52,840 --> 00:11:55,203
‫verwenden, um ein Passwort im Grunde zu verschlüsseln.

232
00:11:58,620 --> 00:12:00,820
‫Das ist also ein neues Paket, das

233
00:12:00,820 --> 00:12:04,130
‫wir vorher noch nicht verwendet haben, und es heißt Crypto,

234
00:12:04,130 --> 00:12:07,063
‫aber ich habe bereits erwähnt, dass alle Funktionen dieses

235
00:12:07,960 --> 00:12:11,260
‫Pakets automatisch von der Ereignisschleife in den Thread-Pool ausgelagert werden,

236
00:12:11,260 --> 00:12:13,280
‫und das ist es, was wir

237
00:12:13,280 --> 00:12:14,780
‫Werde es jetzt testen.

238
00:12:18,380 --> 00:12:22,070
‫Und lass uns das jetzt verwenden, also Krypto. pb, also werden wir eine

239
00:12:22,070 --> 00:12:25,303
‫Verschlüsselungsfunktion namens pbkdf2 verwenden, so ein seltsamer Name, und

240
00:12:27,610 --> 00:12:31,050
‫jetzt übergeben wir den geheimen String, der einfach Passwort

241
00:12:31,050 --> 00:12:34,640
‫sagen soll, dann brauchen wir einen String, um die Passwörter

242
00:12:34,640 --> 00:12:37,520
‫zu lösen, und die Implementierungen hier spielt

243
00:12:37,520 --> 00:12:40,820
‫keine Rolle, also werde ich jetzt nicht ins Detail

244
00:12:40,820 --> 00:12:42,970
‫gehen, wie das funktioniert, das

245
00:12:42,970 --> 00:12:46,150
‫machen wir später, okay, hier brauchen wir nur

246
00:12:46,150 --> 00:12:48,320
‫die Schlüssellänge, also ist diese Zahl

247
00:12:48,320 --> 00:12:50,070
‫hier nur für

248
00:12:50,070 --> 00:12:53,870
‫die Anzahl der Iterationen, dann ist dies die Schlüssellänge und

249
00:12:53,870 --> 00:12:56,020
‫schließlich der Algorithmus, der verwendet

250
00:12:56,020 --> 00:12:58,430
‫wird, um das Passwort zu verschlüsseln.

251
00:12:58,430 --> 00:13:00,380
‫Diese Zahlen erhöhen also einfach die

252
00:13:00,380 --> 00:13:02,483
‫Zeit, die für die Verschlüsselung benötigt wird.

253
00:13:04,970 --> 00:13:08,610
‫Okay, und schließlich braucht es auch eine Callback-Funktion, und alles, was ich hier tun werde, ist

254
00:13:08,610 --> 00:13:11,483
‫eine andere Konsole zu tun. log,

255
00:13:12,730 --> 00:13:16,453
‫und sagen Sie einfach Passwort verschlüsselt.

256
00:13:17,950 --> 00:13:20,740
‫Nun, zum Zweck dieser Demonstration möchte

257
00:13:20,740 --> 00:13:24,220
‫ich Ihnen eigentlich zeigen, wie viel Zeit

258
00:13:24,220 --> 00:13:27,400
‫jede dieser Operationen in Anspruch nimmt. Wir

259
00:13:27,400 --> 00:13:32,010
‫werden also zu Beginn eine Variable im Grunde definieren und

260
00:13:32,010 --> 00:13:37,010
‫auf das Datum setzen. Nun, das ist das aktuelle Datum

261
00:13:37,120 --> 00:13:41,310
‫in Millisekunden, und hier müssen wir nur noch nicht nur die

262
00:13:41,310 --> 00:13:46,310
‫Zeichenfolge, sondern auch das Datum protokollieren. Nun, dies ist das Datum an

263
00:13:46,310 --> 00:13:49,700
‫diesem Punkt in Millisekunden, abzüglich des Starts,

264
00:13:49,700 --> 00:13:53,010
‫und so erhalten wir die Anzahl der

265
00:13:53,010 --> 00:13:55,380
‫Millisekunden, die vergangen sind, um

266
00:13:55,380 --> 00:13:57,380
‫diese Berechnung durchzuführen.

267
00:13:57,380 --> 00:13:59,693
‫Okay, also probieren wir

268
00:14:00,890 --> 00:14:05,360
‫es aus, speichern es und führen es erneut aus, und hier

269
00:14:05,360 --> 00:14:08,530
‫sehen Sie, dass es 1855 Millisekunden, also

270
00:14:08,530 --> 00:14:12,250
‫fast zwei Sekunden dauerte, um dieses Passwort zu verschlüsseln.

271
00:14:12,250 --> 00:14:15,110
‫Okay, aber jetzt lassen Sie uns diesen Code tatsächlich

272
00:14:15,110 --> 00:14:17,360
‫duplizieren, oder eigentlich möchte ich vier

273
00:14:17,360 --> 00:14:19,660
‫Instanzen davon, um Ihnen etwas zu zeigen.

274
00:14:19,660 --> 00:14:23,400
‫Wenn wir das jetzt also ausführen, sollte es wahrscheinlich ungefähr gleich lange

275
00:14:23,400 --> 00:14:25,710
‫dauern, und ja, das tut es, also

276
00:14:25,710 --> 00:14:27,980
‫war es 1. 8 Sekunden,

277
00:14:27,980 --> 00:14:31,620
‫jetzt sind es 2. 2 Sekunden, was ziemlich ähnlich ist.

278
00:14:31,620 --> 00:14:34,530
‫Okay, und denken Sie daran, dass ich Ihnen

279
00:14:34,530 --> 00:14:36,630
‫in einer der früheren Vorlesungen

280
00:14:36,630 --> 00:14:39,360
‫gesagt habe, dass die Größe des Thread-Pools

281
00:14:39,360 --> 00:14:41,720
‫standardmäßig vier ist, also vier Threads

282
00:14:41,720 --> 00:14:44,010
‫gleichzeitig die Arbeit erledigen, und

283
00:14:44,010 --> 00:14:46,160
‫deshalb dauern diese vier Passwortverschlüsselungen

284
00:14:46,160 --> 00:14:48,000
‫ungefähr zur gleichen

285
00:14:48,000 --> 00:14:50,740
‫Zeit und passieren im Grunde alle gleichzeitig.

286
00:14:50,740 --> 00:14:53,990
‫Aber wir können diese Thread-Pool-Größe tatsächlich ändern.

287
00:14:53,990 --> 00:14:57,100
‫Lassen Sie mich Ihnen also zeigen, wie wir das tun, und wir tun

288
00:14:57,100 --> 00:14:59,867
‫dies, indem wir Prozess sagen. env, und

289
00:15:01,290 --> 00:15:03,230
‫das ist eine Umgebungsvariable, und

290
00:15:03,230 --> 00:15:05,680
‫darüber werden wir später noch einmal

291
00:15:06,684 --> 00:15:08,613
‫sprechen, und UV, was

292
00:15:11,232 --> 00:15:15,500
‫für LibUV steht, Threadpool-Größe. Wenn wir dies also auf eins setzen,

293
00:15:15,500 --> 00:15:18,783
‫haben wir nur einen Thread in unserem Thread-Pool.

294
00:15:21,110 --> 00:15:26,110
‫Versuchen wir es noch einmal und sehen wir, was jetzt passiert.

295
00:15:28,650 --> 00:15:32,840
‫Sie sehen also, dass sie alle viel länger brauchen, um sie zu berechnen.

296
00:15:32,840 --> 00:15:35,490
‫Grundsätzlich werden sie nacheinander berechnet.

297
00:15:35,490 --> 00:15:38,470
‫Also dieser die erste, dann dieser hier dauert die

298
00:15:38,470 --> 00:15:40,610
‫doppelte Zeit, und das liegt wiederum

299
00:15:40,610 --> 00:15:42,980
‫daran, dass dieser erst beginnen kann, sobald der

300
00:15:42,980 --> 00:15:45,160
‫erste fertig ist, und der gleiche mit

301
00:15:45,160 --> 00:15:46,893
‫dem dritten und vierten.

302
00:15:47,920 --> 00:15:49,620
‫Nehmen wir nun an,

303
00:15:52,170 --> 00:15:54,300
‫wir ändern es auf zwei, dann sollten

304
00:15:54,300 --> 00:15:56,990
‫wir die ersten beiden mit derselben Zeit sehen und

305
00:15:56,990 --> 00:15:59,710
‫genau die zweiten beiden auch mit einer ähnlichen Zeit.

306
00:15:59,710 --> 00:16:01,363
‫Das macht also Sinn, richtig.

307
00:16:02,650 --> 00:16:04,500
‫Nur der Vollständigkeit halber

308
00:16:05,610 --> 00:16:08,950
‫hier jetzt gleich mit drei, also haben diese drei

309
00:16:08,950 --> 00:16:11,340
‫eine ähnliche Zeit, und dann die letzte.

310
00:16:11,340 --> 00:16:15,440
‫Okay, so funktioniert der Thread-Pool im Grunde, also habe ich mich

311
00:16:15,440 --> 00:16:18,660
‫entschieden, mich nicht nur auf die Ereignisschleife zu

312
00:16:18,660 --> 00:16:22,630
‫konzentrieren, sondern Ihnen auch einen schnellen Überblick über den Thread-Pool zu

313
00:16:22,630 --> 00:16:25,010
‫geben und wie wir die Thread-Pool-Größe

314
00:16:25,010 --> 00:16:27,620
‫ändern können , okay, bedenken Sie, dass

315
00:16:27,620 --> 00:16:29,560
‫dieser Code hier eigentlich

316
00:16:29,560 --> 00:16:33,230
‫immer noch asynchron ist, weil wir eine Callback-Funktion übergeben haben.

317
00:16:33,230 --> 00:16:36,490
‫Okay, und wir könnten tatsächlich die synchrone Version verwenden, aber

318
00:16:36,490 --> 00:16:38,920
‫das würde dann die Ereignisschleife blockieren.

319
00:16:38,920 --> 00:16:40,650
‫Willst du das sehen?

320
00:16:40,650 --> 00:16:43,183
‫Also lass mich dir das auch ganz schnell zeigen, so

321
00:16:44,120 --> 00:16:46,130
‫dass einer nicht wirklich geplant war, aber

322
00:16:46,130 --> 00:16:48,240
‫machen wir es trotzdem, denn es ist sehr

323
00:16:48,240 --> 00:16:50,090
‫interessant zu sehen, wie ich finde.

324
00:16:51,580 --> 00:16:53,830
‫Okay, das wird so funktionieren.

325
00:16:53,830 --> 00:16:57,570
‫Wir verwenden wieder die Sync-Version der gleichen Funktion,

326
00:16:57,570 --> 00:16:59,950
‫die oft zur Verfügung steht.

327
00:16:59,950 --> 00:17:02,760
‫Denken Sie daran, dass wir dasselbe für die read

328
00:17:02,760 --> 00:17:05,190
‫file haben, also haben wir read file,

329
00:17:05,190 --> 00:17:08,290
‫die einen Rückruf akzeptiert, und wir haben read file sync,

330
00:17:08,290 --> 00:17:11,440
‫die synchrone Version, die keinen Rückruf akzeptiert, also einfach so.

331
00:17:11,440 --> 00:17:13,520
‫Dieser verschlüsselt dann das Passwort,

332
00:17:13,520 --> 00:17:16,890
‫blockiert die Codeausführung und geht dann zur nächsten Zeile über,

333
00:17:16,890 --> 00:17:19,700
‫die dies dann hier an der Konsole protokolliert.

334
00:17:19,700 --> 00:17:21,823
‫Lassen Sie uns das jetzt hier duplizieren.

335
00:17:23,570 --> 00:17:26,553
‫Das war zu viel, lösche dieses

336
00:17:27,500 --> 00:17:31,310
‫hier, und so laufen diese vier Passwortverschlüsselungen jetzt nicht

337
00:17:31,310 --> 00:17:33,350
‫mehr in der Ereignisschleife.

338
00:17:33,350 --> 00:17:37,070
‫Daher werden sie nicht mehr in den Thread-Pool ausgelagert.

339
00:17:37,070 --> 00:17:39,980
‫Okay, und jetzt, selbst wenn wir die Thread-Pool-Größe von

340
00:17:39,980 --> 00:17:42,583
‫vier haben, wollen wir sehen, was passiert.

341
00:17:46,010 --> 00:17:50,080
‫Sie sehen also, sie laufen völlig synchron ab.

342
00:17:50,080 --> 00:17:53,290
‫Also einer nach dem anderen, und was noch

343
00:17:53,290 --> 00:17:55,350
‫schlimmer ist, ist, dass

344
00:17:55,350 --> 00:17:57,960
‫alle diese Timer hier, sogar nextTick

345
00:17:57,960 --> 00:18:01,850
‫und der unmittelbare, erst auftauchten, nachdem die Passwortverschlüsselungen stattgefunden hatten.

346
00:18:01,850 --> 00:18:04,990
‫Das blockierte also wirklich die gesamte Ausführung, auch

347
00:18:04,990 --> 00:18:07,460
‫wenn dieser Timer hier, zum Beispiel dieser

348
00:18:07,460 --> 00:18:09,580
‫hier, nach null Sekunden beendet

349
00:18:09,580 --> 00:18:11,440
‫war und dieser nach

350
00:18:11,440 --> 00:18:13,830
‫drei Sekunden, aber alle müssen sieben

351
00:18:13,830 --> 00:18:16,010
‫Sekunden warten, bis all diese

352
00:18:16,010 --> 00:18:19,670
‫Passwortverschlüsselungen hier waren endlich fertig, wieder weil sie nicht innerhalb

353
00:18:19,670 --> 00:18:22,120
‫der Ereignisschleife liefen, aber diese waren.

354
00:18:22,120 --> 00:18:24,960
‫Und so arbeiteten sie im

355
00:18:24,960 --> 00:18:26,890
‫Grunde im

356
00:18:26,890 --> 00:18:29,470
‫Hintergrund und konnten erst

357
00:18:29,470 --> 00:18:32,110
‫von der Ereignisschleife erfasst

358
00:18:32,110 --> 00:18:34,760
‫werden, wenn sie bereit

359
00:18:34,760 --> 00:18:38,240
‫waren, direkt nach diesen vier Passwortverschlüsselungen.

360
00:18:38,240 --> 00:18:41,600
‫Okay, das war genug für einen Vortrag, ich hoffe, Sie

361
00:18:41,600 --> 00:18:43,270
‫fanden ihn interessant, und

362
00:18:43,270 --> 00:18:45,220
‫wir sehen uns gleich im nächsten.

