1
00:00:01,190 --> 00:00:02,840
‫Jonas: Agora vamos

2
00:00:02,840 --> 00:00:05,520
‫escrever um código para entender melhor o

3
00:00:05,520 --> 00:00:07,893
‫que acontece no loop de eventos.

4
00:00:09,200 --> 00:00:11,370
‫Assim como antes, para começar

5
00:00:11,370 --> 00:00:13,670
‫com a parte de codificação desta seção,

6
00:00:13,670 --> 00:00:15,970
‫vá em frente e pegue os arquivos

7
00:00:15,970 --> 00:00:18,550
‫iniciais para esta seção, copie-os em algum lugar

8
00:00:18,550 --> 00:00:22,050
‫e, em seguida, abra o projeto em seu editor de código.

9
00:00:22,050 --> 00:00:24,310
‫Então, eu o tenho aqui na área de

10
00:00:24,310 --> 00:00:27,550
‫trabalho e no meu VSCode, e tudo o que temos aqui para

11
00:00:27,550 --> 00:00:31,420
‫começar é este arquivo de teste. txt, então vou criar um novo arquivo aqui,

12
00:00:31,420 --> 00:00:35,033
‫e vou chamá-lo de loop de evento. js.

13
00:00:38,040 --> 00:00:41,530
‫Tudo bem, agora é extremamente difícil simular o loop

14
00:00:41,530 --> 00:00:44,000
‫de evento corretamente, porque não podemos realmente

15
00:00:44,000 --> 00:00:46,400
‫colocar muitos callbacks em todas as

16
00:00:46,400 --> 00:00:48,080
‫filas de callback

17
00:00:48,080 --> 00:00:51,260
‫que falamos antes, tudo ao mesmo tempo, certo.

18
00:00:51,260 --> 00:00:53,710
‫Essa situação acontece quando, por

19
00:00:53,710 --> 00:00:56,360
‫exemplo, muitas solicitações chegam ao seu

20
00:00:56,360 --> 00:01:00,240
‫aplicativo, mas aqui localmente, isso é muito difícil de replicar.

21
00:01:00,240 --> 00:01:03,150
‫Mas de qualquer forma, ainda faremos alguns experimentos

22
00:01:03,150 --> 00:01:05,390
‫muito interessantes usando algumas das coisas

23
00:01:05,390 --> 00:01:07,540
‫que aprendemos no último vídeo.

24
00:01:07,540 --> 00:01:09,830
‫E o que vamos fazer é

25
00:01:09,830 --> 00:01:12,190
‫escrever um monte de linhas de código

26
00:01:12,190 --> 00:01:15,130
‫e, em seguida, tentar descobrir em que ordem elas

27
00:01:15,130 --> 00:01:17,950
‫devem ser executadas no loop de eventos e analisar

28
00:01:17,950 --> 00:01:20,360
‫se os resultados que obtemos realmente fazem sentido.

29
00:01:20,360 --> 00:01:22,710
‫Então, vamos começar escrevendo um setTimeout,

30
00:01:24,290 --> 00:01:26,513
‫basicamente, para definir um temporizador,

31
00:01:27,980 --> 00:01:29,890
‫estou usando uma função de

32
00:01:29,890 --> 00:01:31,270
‫seta aqui,

33
00:01:31,270 --> 00:01:33,773
‫e a única coisa que farei é

34
00:01:34,930 --> 00:01:39,930
‫registrar para console alguma string, então console. log, cronômetro um terminou, e

35
00:01:41,800 --> 00:01:45,390
‫eu quero que isso expire logo após zero segundos.

36
00:01:45,390 --> 00:01:47,740
‫Ok, salve, e então você verá que

37
00:01:47,740 --> 00:01:50,030
‫ele realmente corrigiu essa string aqui, então

38
00:01:50,030 --> 00:01:53,120
‫mudou as aspas e adicionou o ponto-e-vírgula, e isso

39
00:01:53,120 --> 00:01:54,810
‫é por causa da

40
00:01:54,810 --> 00:01:56,940
‫extensão mais Prettier que instalamos antes.

41
00:01:56,940 --> 00:01:58,510
‫Agora não vou configurá-lo aqui,

42
00:01:58,510 --> 00:01:59,850
‫porque para esse pequeno

43
00:01:59,850 --> 00:02:02,050
‫exemplo, isso não é realmente necessário, ok.

44
00:02:02,050 --> 00:02:05,150
‫Então isso é definir um cronômetro,

45
00:02:05,150 --> 00:02:09,320
‫então vamos usar setImmediate, então lembre-se disso no último vídeo.

46
00:02:09,320 --> 00:02:11,620
‫Ok, agora não vou explicar muito aqui, por

47
00:02:11,620 --> 00:02:13,350
‫enquanto vamos escrever esse código

48
00:02:13,350 --> 00:02:15,510
‫e depois analisar o que acontece, ok.

49
00:02:15,510 --> 00:02:20,320
‫Portanto, setImmediate e, assim como o outro cronômetro, recebe uma função

50
00:02:20,320 --> 00:02:22,500
‫de retorno de chamada.

51
00:02:22,500 --> 00:02:25,130
‫E tudo o que vamos fazer é

52
00:02:27,720 --> 00:02:31,440
‫escrever imediatamente um acabado, e esse aqui não tem

53
00:02:31,440 --> 00:02:33,520
‫tempo, porque não é

54
00:02:33,520 --> 00:02:36,930
‫necessário porque como o nome diz, é imediato.

55
00:02:36,930 --> 00:02:38,540
‫Então outra coisa que queremos

56
00:02:38,540 --> 00:02:41,620
‫fazer é ler este arquivo aqui, e então passar

57
00:02:41,620 --> 00:02:44,930
‫uma função de retorno de chamada, ok, então a primeira

58
00:02:44,930 --> 00:02:48,963
‫coisa é que temos que exigir o módulo correto, então FS, e

59
00:02:52,600 --> 00:02:54,987
‫agora fs. readFile, e queremos um arquivo de texto. txt,

60
00:03:05,586 --> 00:03:08,003
‫e então algo acontecerá.

61
00:03:09,270 --> 00:03:12,153
‫E assim como antes, vamos apenas dizer

62
00:03:13,740 --> 00:03:17,263
‫aqui, neste caso o I / O terminou, certo.

63
00:03:18,830 --> 00:03:21,170
‫Então, I / O porque este retorno

64
00:03:21,170 --> 00:03:24,830
‫de chamada aqui está realmente relacionado a uma tarefa de I / O,

65
00:03:24,830 --> 00:03:28,440
‫que na verdade obtém sua própria fase no loop de eventos, certo.

66
00:03:28,440 --> 00:03:31,930
‫E, finalmente, vamos adicionar um console. logar aqui, dizendo

67
00:03:31,930 --> 00:03:35,473
‫bem, olá do código de nível superior.

68
00:03:37,517 --> 00:03:40,440
‫Ok, e código de nível superior, porque é realmente o único

69
00:03:40,440 --> 00:03:43,130
‫que não está dentro de nenhum retorno de chamada.

70
00:03:43,130 --> 00:03:46,000
‫Portanto, neste pequeno exemplo que temos por agora, vamos

71
00:03:46,000 --> 00:03:48,400
‫tentar descobrir o que deve acontecer primeiro.

72
00:03:48,400 --> 00:03:50,510
‫Bem, lembre-se de que a primeira

73
00:03:50,510 --> 00:03:53,310
‫etapa ao carregar um módulo é que seu

74
00:03:53,310 --> 00:03:56,000
‫código de nível superior seja executado, portanto, imediatamente

75
00:03:56,000 --> 00:03:59,360
‫devemos ver este console. log aqui, certo, só

76
00:03:59,360 --> 00:04:02,110
‫então mais tarde devemos ver os outros logs

77
00:04:02,110 --> 00:04:04,280
‫vindos desses outros callbacks, porque esses

78
00:04:04,280 --> 00:04:06,820
‫callbacks vão realmente rodar no loop de eventos.

79
00:04:06,820 --> 00:04:09,190
‫Então, vamos tentar ver se esse é realmente

80
00:04:09,190 --> 00:04:12,000
‫o caso e, em seguida, analisar um pouco melhor ainda.

81
00:04:12,000 --> 00:04:15,150
‫Abrindo o console aqui, e novamente, estou

82
00:04:15,150 --> 00:04:17,250
‫fazendo isso usando o

83
00:04:17,250 --> 00:04:22,023
‫terminal, ou realmente na visualização, então este terminal aqui, tudo bem.

84
00:04:23,100 --> 00:04:27,020
‫Portanto, observe, evento-loop. js, ou na verdade antes

85
00:04:27,020 --> 00:04:30,960
‫de fazermos isso, preciso corrigir esse erro de digitação aqui, então é um

86
00:04:30,960 --> 00:04:33,580
‫arquivo de teste, não um arquivo de texto.

87
00:04:33,580 --> 00:04:36,093
‫Ok, mas agora estamos prontos para executar

88
00:04:36,960 --> 00:04:40,320
‫este comando e os resultados estão disponíveis, então o primeiro

89
00:04:40,320 --> 00:04:43,810
‫log que temos aqui é oi do código de nível

90
00:04:43,810 --> 00:04:46,100
‫superior, e isso era esperado, certo,

91
00:04:46,100 --> 00:04:49,390
‫porque este é um código que é executado imediatamente.

92
00:04:49,390 --> 00:04:52,940
‫Depois disso, temos essas três saídas, mas na verdade elas não estão

93
00:04:52,940 --> 00:04:55,460
‫em uma ordem particular, e isso é porque esse

94
00:04:55,460 --> 00:04:57,640
‫código aqui, então esse código, não

95
00:04:57,640 --> 00:05:00,970
‫está realmente em um ciclo de E / S, então não

96
00:05:00,970 --> 00:05:03,780
‫está sendo executado dentro do loop de eventos, porque

97
00:05:03,780 --> 00:05:07,170
‫não está sendo executado dentro de nenhuma função de retorno de chamada.

98
00:05:07,170 --> 00:05:10,370
‫Ok, então em seu computador, você pode realmente ver

99
00:05:11,470 --> 00:05:13,160
‫este log aqui antes

100
00:05:13,160 --> 00:05:15,360
‫deste, e este aqui é apenas

101
00:05:15,360 --> 00:05:18,550
‫o último porque este tipo de arquivo aqui leva

102
00:05:18,550 --> 00:05:20,840
‫algum tempo para ser lido e

103
00:05:20,840 --> 00:05:23,060
‫provavelmente sempre será o último 1.

104
00:05:23,060 --> 00:05:27,140
‫Então, novamente, neste ponto, a ordem desses três aqui não tem nada

105
00:05:27,140 --> 00:05:29,640
‫a ver com o loop de eventos, porque

106
00:05:29,640 --> 00:05:31,320
‫eles ainda não estão

107
00:05:31,320 --> 00:05:33,420
‫executando dentro do loop de eventos.

108
00:05:33,420 --> 00:05:36,490
‫Para isso, teremos que movê-los, ou pelo

109
00:05:36,490 --> 00:05:40,490
‫menos mover esses dois aqui, dentro de uma função de callback.

110
00:05:40,490 --> 00:05:43,713
‫E então, para isso, vamos usar este aqui, na verdade.

111
00:05:45,270 --> 00:05:50,190
‫Deixe-me colocá-lo aqui, e dizer o temporizador dois e o temporizador dois

112
00:05:50,190 --> 00:05:55,190
‫aqui, ou imediatamente dois, e também vou adicionar outro temporizador aqui, então o

113
00:05:55,270 --> 00:05:57,740
‫temporizador três, e este vai

114
00:05:57,740 --> 00:06:01,140
‫funcionar por três segundos, ou seja, 3.000 milissegundos .

115
00:06:01,140 --> 00:06:03,840
‫Então, vamos agora tentar o resultado deste.

116
00:06:03,840 --> 00:06:06,230
‫Mas antes de fazermos isso, vamos

117
00:06:06,230 --> 00:06:09,660
‫realmente pensar por que logo depois que todo o código

118
00:06:09,660 --> 00:06:13,730
‫anterior foi executado, o programa saiu e voltou para o prompt aqui.

119
00:06:13,730 --> 00:06:16,500
‫Portanto, lembre-se de como o Node. js decide se deve

120
00:06:16,500 --> 00:06:19,000
‫continuar executando o loop de eventos, bem, ele o

121
00:06:19,000 --> 00:06:21,620
‫faz perguntando se ainda há algum tempo em execução

122
00:06:21,620 --> 00:06:24,580
‫em segundo plano e, se for o caso, não terminará

123
00:06:24,580 --> 00:06:26,800
‫e se ainda houver um temporizador pendente,

124
00:06:26,800 --> 00:06:29,140
‫bem, então não é vai sair do programa.

125
00:06:29,140 --> 00:06:30,920
‫Mas se não houver, que

126
00:06:30,920 --> 00:06:33,920
‫era o caso no primeiro exemplo aqui, ele sai

127
00:06:33,920 --> 00:06:36,660
‫imediatamente do programa, ok, mas agora temos um

128
00:06:36,660 --> 00:06:38,980
‫temporizador aqui, então este funcionará por

129
00:06:38,980 --> 00:06:41,620
‫três segundos, então vamos tentar descobrir o

130
00:06:41,620 --> 00:06:43,220
‫que acontece aqui.

131
00:06:45,260 --> 00:06:47,450
‫Ok, então você vê que ele

132
00:06:47,450 --> 00:06:50,640
‫não está saindo, e só agora, depois que o

133
00:06:50,640 --> 00:06:53,170
‫cronômetro três terminou, ele saiu do aplicativo.

134
00:06:53,170 --> 00:06:56,100
‫Ok, então vamos ver isso de novo,

135
00:06:56,100 --> 00:06:59,480
‫todos esses cronômetros de registros em execução, cronômetro

136
00:06:59,480 --> 00:07:02,070
‫finalizado e, portanto, saiu do aplicativo.

137
00:07:02,070 --> 00:07:04,490
‫Agora, sobre esses resultados aqui, vamos realmente

138
00:07:04,490 --> 00:07:06,820
‫tornar isso aqui um pouco mais

139
00:07:06,820 --> 00:07:10,113
‫fácil de ver e adicionar apenas um pequeno separador aqui.

140
00:07:11,360 --> 00:07:14,683
‫Ok, limpe isso, ok.

141
00:07:16,510 --> 00:07:19,600
‫Portanto, esses quatro aqui são as saídas que não

142
00:07:19,600 --> 00:07:22,110
‫estavam realmente sendo executadas no loop de

143
00:07:22,110 --> 00:07:24,380
‫eventos, mas esses três aqui estavam

144
00:07:24,380 --> 00:07:28,150
‫realmente saindo do loop de eventos, então vamos agora analisar esses resultados.

145
00:07:28,150 --> 00:07:29,980
‫Agora, se você

146
00:07:29,980 --> 00:07:32,690
‫se lembrar do diagrama da aula anterior,

147
00:07:32,690 --> 00:07:36,960
‫provavelmente terá pensado que o cronômetro, então o cronômetro dois aqui,

148
00:07:36,960 --> 00:07:39,640
‫deveria realmente terminar antes do setImmediate,

149
00:07:39,640 --> 00:07:42,640
‫porque no diagrama, ele realmente apareceu primeiro bem

150
00:07:42,640 --> 00:07:45,100
‫no topo do loop de eventos.

151
00:07:45,100 --> 00:07:48,090
‫Portanto, temos que definir o tempo limite

152
00:07:48,090 --> 00:07:52,500
‫aqui com zero, que deve ser o mesmo que setImmediate, certo.

153
00:07:52,500 --> 00:07:54,610
‫Então, por que

154
00:07:54,610 --> 00:07:57,630
‫setImmediate realmente aparece antes de setTimeout?

155
00:07:57,630 --> 00:08:00,020
‫Bem, há algo que eu realmente

156
00:08:00,020 --> 00:08:02,470
‫não expliquei no último vídeo, porque não queria

157
00:08:02,470 --> 00:08:05,750
‫torná-lo ainda mais confuso, e é que o loop de

158
00:08:05,750 --> 00:08:09,320
‫eventos realmente espera que as coisas aconteçam na fase de votação.

159
00:08:09,320 --> 00:08:12,270
‫Portanto, nessa fase em que os retornos de chamada de E / S são tratados.

160
00:08:12,270 --> 00:08:15,400
‫Então, quando esta fila de retornos de chamada está vazia, que

161
00:08:15,400 --> 00:08:17,940
‫é o caso em nosso exemplo fictício aqui, então

162
00:08:17,940 --> 00:08:20,270
‫não temos retornos de chamada de E

163
00:08:20,270 --> 00:08:23,500
‫/ S, tudo o que temos são esses temporizadores, bem, então

164
00:08:23,500 --> 00:08:27,490
‫o loop de evento irá esperar nesta fase até que haja um expirado cronômetro.

165
00:08:27,490 --> 00:08:31,430
‫Mas, se agendamos um retorno de chamada usando setImmediate,

166
00:08:31,430 --> 00:08:34,320
‫esse retorno de chamada será executado imediatamente

167
00:08:34,320 --> 00:08:36,920
‫após a fase de pesquisa

168
00:08:36,920 --> 00:08:40,240
‫e mesmo antes de temporizadores expirados, se houver.

169
00:08:40,240 --> 00:08:43,270
‫E, neste caso, o cronômetro expira imediatamente, portanto, após

170
00:08:43,270 --> 00:08:46,080
‫zero segundos, mas novamente, o loop de eventos

171
00:08:46,080 --> 00:08:49,710
‫realmente espera, então ele faz uma pausa na fase de votação.

172
00:08:49,710 --> 00:08:52,100
‫E para que o retorno de

173
00:08:52,100 --> 00:08:55,580
‫chamada setImmediate seja realmente executado primeiro, essa é a

174
00:08:55,580 --> 00:08:59,730
‫razão pela qual temos esse imediato aqui depois de termos os temporizadores.

175
00:08:59,730 --> 00:09:02,770
‫Ok, e eu sei que isso parece muito confuso, e

176
00:09:02,770 --> 00:09:04,810
‫eu concordo totalmente, mas esse é apenas

177
00:09:04,810 --> 00:09:08,090
‫o jeito do Node. js funciona.

178
00:09:08,090 --> 00:09:11,380
‫E agora vamos tornar isso um pouco mais confuso e

179
00:09:11,380 --> 00:09:14,250
‫adicionar o processo. nextTick que

180
00:09:14,250 --> 00:09:16,950
‫falamos também na última aula.

181
00:09:16,950 --> 00:09:21,950
‫Portanto, dizemos processo. nextTick e, como antes, simplesmente passamos uma

182
00:09:22,170 --> 00:09:24,323
‫função de retorno de chamada.

183
00:09:25,540 --> 00:09:27,640
‫E novamente, eu só quero fazer login

184
00:09:27,640 --> 00:09:31,663
‫no console, e vou dizer processo. nextTick.

185
00:09:32,550 --> 00:09:36,150
‫Então, o que você acha que vai acontecer neste caso?

186
00:09:36,150 --> 00:09:40,170
‫Vá em frente e faça uma suposição e, quando estiver pronto, você

187
00:09:40,170 --> 00:09:42,883
‫pode executar isso, então vamos fazer isso.

188
00:09:44,120 --> 00:09:48,280
‫Salve-o aqui primeiro, execute-o e aqui vamos nós.

189
00:09:48,280 --> 00:09:51,760
‫Portanto, os resultados estão novamente disponíveis, e agora o

190
00:09:51,760 --> 00:09:55,640
‫primeiro retorno de chamada executado foi, na verdade, esta função aqui.

191
00:09:55,640 --> 00:09:58,220
‫É por isso que temos processo. nextTick à

192
00:09:58,220 --> 00:09:59,710
‫direita no primeiro.

193
00:09:59,710 --> 00:10:03,500
‫Então, por que essa função de callback do processo. nextTick o primeiro

194
00:10:03,500 --> 00:10:06,570
‫de todos eles a ser executado?

195
00:10:06,570 --> 00:10:09,070
‫Bem, lembre-se de que nextTick

196
00:10:09,070 --> 00:10:12,410
‫faz parte da fila de microtarefas, que são

197
00:10:12,410 --> 00:10:16,530
‫executadas após cada fase, não apenas após um tick inteiro.

198
00:10:16,530 --> 00:10:19,120
‫E então o que aconteceu aqui é que

199
00:10:19,120 --> 00:10:23,660
‫essa função de retorno de chamada realmente foi executada antes da fase em que essa função

200
00:10:23,660 --> 00:10:26,970
‫de retorno de chamada foi executada, e a fase anterior, tudo bem.

201
00:10:26,970 --> 00:10:30,850
‫Agora nextTick é na verdade um nome enganoso, porque um tick

202
00:10:30,850 --> 00:10:33,990
‫é na verdade um loop inteiro, mas nextTick

203
00:10:33,990 --> 00:10:37,860
‫realmente acontece antes da próxima fase do loop, e não

204
00:10:37,860 --> 00:10:41,990
‫de todo o tick, então é o que eu estava dizendo antes.

205
00:10:41,990 --> 00:10:45,830
‫Então, por outro lado, setImmediate faria você pensar

206
00:10:45,830 --> 00:10:49,690
‫que seu retorno de chamada seria executado imediatamente, mas

207
00:10:49,690 --> 00:10:52,780
‫na verdade não é, certo, então

208
00:10:52,780 --> 00:10:55,570
‫setImmediate é executado uma vez

209
00:10:55,570 --> 00:10:58,800
‫por tick, enquanto nextTick é executado imediatamente.

210
00:10:58,800 --> 00:11:01,820
‫E então seus dois nomes devem ser trocados.

211
00:11:01,820 --> 00:11:03,700
‫Eles deveriam ser o contrário, e isso

212
00:11:03,700 --> 00:11:05,390
‫pode causar muita confusão, então

213
00:11:05,390 --> 00:11:08,440
‫é melhor sempre apenas se ater a um deles, e isso

214
00:11:08,440 --> 00:11:12,470
‫geralmente é definido como imediato e não processado. nextTick.

215
00:11:12,470 --> 00:11:15,070
‫De qualquer forma, como mencionei no último vídeo,

216
00:11:15,070 --> 00:11:18,530
‫esses mecanismos são na verdade mais para casos de uso bastante

217
00:11:18,530 --> 00:11:20,320
‫avançados, e é por isso

218
00:11:20,320 --> 00:11:22,760
‫que provavelmente não os usaremos em nosso projeto.

219
00:11:22,760 --> 00:11:24,970
‫Mas se você quiser aprender mais sobre

220
00:11:24,970 --> 00:11:28,060
‫eles, você pode sempre ler a documentação oficial do Node.

221
00:11:28,060 --> 00:11:30,660
‫Ok, então com isso simulamos alguns aspectos do

222
00:11:30,660 --> 00:11:33,250
‫loop de evento, mas para terminar, quero apenas

223
00:11:33,250 --> 00:11:35,500
‫introduzir rapidamente algo sobre o pool

224
00:11:35,500 --> 00:11:38,290
‫de threads também e, para isso, faremos uma

225
00:11:38,290 --> 00:11:40,950
‫operação mais complexa que será transferida para o

226
00:11:40,950 --> 00:11:43,490
‫conjunto de encadeamentos e observe quanto tempo

227
00:11:43,490 --> 00:11:47,040
‫essas operações levam para serem executadas e como podemos alterar o

228
00:11:47,040 --> 00:11:48,510
‫tamanho do conjunto

229
00:11:48,510 --> 00:11:50,870
‫de encadeamentos sobre o qual falamos antes.

230
00:11:50,870 --> 00:11:52,840
‫Então, vamos usar um pouco

231
00:11:52,840 --> 00:11:55,203
‫de criptografia aqui para criptografar basicamente uma senha.

232
00:11:58,620 --> 00:12:00,820
‫Esse é um novo pacote que não

233
00:12:00,820 --> 00:12:04,130
‫tínhamos usado antes e é chamado de Crypto, mas mencionei

234
00:12:04,130 --> 00:12:07,063
‫antes que, na verdade, todas as funções deste pacote

235
00:12:07,960 --> 00:12:11,260
‫serão descarregadas automaticamente pelo loop de eventos para o pool

236
00:12:11,260 --> 00:12:13,280
‫de threads, e é isso que

237
00:12:13,280 --> 00:12:14,780
‫nós vamos testar agora.

238
00:12:18,380 --> 00:12:22,070
‫E vamos usar isso agora, então cripto. pb, então vamos usar uma

239
00:12:22,070 --> 00:12:25,303
‫função de criptografia chamada pbkdf2, um nome meio estranho,

240
00:12:27,610 --> 00:12:31,050
‫e agora passamos a string secreta, que digamos apenas senha,

241
00:12:31,050 --> 00:12:34,640
‫então precisamos de uma string para resolver as senhas, e

242
00:12:34,640 --> 00:12:37,520
‫as implementações aqui realmente não importa, então, por

243
00:12:37,520 --> 00:12:40,820
‫enquanto, não vou entrar em nenhum detalhe de como

244
00:12:40,820 --> 00:12:42,970
‫isso funciona, vamos fazer isso

245
00:12:42,970 --> 00:12:46,150
‫mais tarde, ok, então aqui só precisamos do comprimento

246
00:12:46,150 --> 00:12:48,320
‫da chave, então este número aqui

247
00:12:48,320 --> 00:12:50,070
‫é apenas para

248
00:12:50,070 --> 00:12:53,870
‫o número de iterações, então este é o comprimento da chave

249
00:12:53,870 --> 00:12:56,020
‫e, finalmente, o algoritmo, que

250
00:12:56,020 --> 00:12:58,430
‫será usado para criptografar a senha.

251
00:12:58,430 --> 00:13:00,380
‫Portanto, esses números simplesmente aumentarão

252
00:13:00,380 --> 00:13:02,483
‫o tempo necessário para a criptografia.

253
00:13:04,970 --> 00:13:08,610
‫Ok e finalmente, também tem uma função de retorno de chamada, e tudo o que vou

254
00:13:08,610 --> 00:13:11,483
‫fazer aqui é fazer outro console. log

255
00:13:12,730 --> 00:13:16,453
‫e apenas diga a senha criptografada.

256
00:13:17,950 --> 00:13:20,740
‫Agora, para o propósito desta

257
00:13:20,740 --> 00:13:24,220
‫demonstração, eu realmente quero mostrar quanto tempo

258
00:13:24,220 --> 00:13:27,400
‫cada uma dessas operações leva, então o

259
00:13:27,400 --> 00:13:32,010
‫que vamos fazer é basicamente definir uma variável no

260
00:13:32,010 --> 00:13:37,010
‫início, configurá-la como data. agora, então essa é a data atual em

261
00:13:37,120 --> 00:13:41,310
‫milissegundos, e então aqui, tudo o que temos a fazer é registrar não

262
00:13:41,310 --> 00:13:46,310
‫apenas a string, mas também a data. agora, que será a data

263
00:13:46,310 --> 00:13:49,700
‫neste ponto em milissegundos, menos o início,

264
00:13:49,700 --> 00:13:53,010
‫e isso nos dará a quantidade de

265
00:13:53,010 --> 00:13:55,380
‫milissegundos que se passaram para

266
00:13:55,380 --> 00:13:57,380
‫fazer este cálculo.

267
00:13:57,380 --> 00:13:59,693
‫Ok, então vamos

268
00:14:00,890 --> 00:14:05,360
‫experimentar, salve-o e execute-o novamente, e aqui você vê

269
00:14:05,360 --> 00:14:08,530
‫que demorou 1855 milissegundos, ou seja,

270
00:14:08,530 --> 00:14:12,250
‫quase dois segundos para criptografar essa senha.

271
00:14:12,250 --> 00:14:15,110
‫Ok, mas agora vamos duplicar esse código ou,

272
00:14:15,110 --> 00:14:17,360
‫na verdade, quero quatro instâncias

273
00:14:17,360 --> 00:14:19,660
‫disso para mostrar algo a você.

274
00:14:19,660 --> 00:14:23,400
‫Portanto, se executarmos isso agora, provavelmente levará aproximadamente a mesma

275
00:14:23,400 --> 00:14:25,710
‫quantidade de tempo e, sim, leva, então

276
00:14:25,710 --> 00:14:27,980
‫foi 1. 8

277
00:14:27,980 --> 00:14:31,620
‫segundos, agora são 2. 2 segundos, o que é bastante semelhante.

278
00:14:31,620 --> 00:14:34,530
‫Ok, e lembre-se que eu disse a você em

279
00:14:34,530 --> 00:14:36,630
‫uma das palestras anteriores, que por

280
00:14:36,630 --> 00:14:39,360
‫padrão o tamanho do pool de threads é

281
00:14:39,360 --> 00:14:41,720
‫quatro, então há quatro threads fazendo o

282
00:14:41,720 --> 00:14:44,010
‫trabalho ao mesmo tempo, e é por

283
00:14:44,010 --> 00:14:46,160
‫isso que essas quatro criptografias de

284
00:14:46,160 --> 00:14:48,000
‫senha demoram aproximadamente ao

285
00:14:48,000 --> 00:14:50,740
‫mesmo tempo e acontecem basicamente ao mesmo tempo.

286
00:14:50,740 --> 00:14:53,990
‫Mas podemos realmente alterar o tamanho do pool de threads.

287
00:14:53,990 --> 00:14:57,100
‫Então, deixe-me mostrar como fazemos isso, e fazemos

288
00:14:57,100 --> 00:14:59,867
‫isso dizendo processo. env, e

289
00:15:01,290 --> 00:15:03,230
‫essa é uma variável de

290
00:15:03,230 --> 00:15:05,680
‫ambiente, e mais uma vez falaremos mais

291
00:15:06,684 --> 00:15:08,613
‫sobre isso mais tarde, e

292
00:15:11,232 --> 00:15:15,500
‫UV, que significa LibUV, tamanho do threadpool, então se definirmos como um,

293
00:15:15,500 --> 00:15:18,783
‫teremos apenas um thread em nosso pool de threads.

294
00:15:21,110 --> 00:15:26,110
‫Então, vamos tentar de novo e ver o que acontece agora.

295
00:15:28,650 --> 00:15:32,840
‫Então você vê que todos eles demoram muito mais para serem calculados.

296
00:15:32,840 --> 00:15:35,490
‫Basicamente, eles são calculados um após o outro.

297
00:15:35,490 --> 00:15:38,470
‫Então este é o primeiro, então este aqui leva o

298
00:15:38,470 --> 00:15:40,610
‫dobro do tempo, e de novo isso

299
00:15:40,610 --> 00:15:42,980
‫porque este só pode começar assim que o

300
00:15:42,980 --> 00:15:45,160
‫primeiro estiver concluído, e o mesmo com

301
00:15:45,160 --> 00:15:46,893
‫o terceiro e o quarto.

302
00:15:47,920 --> 00:15:49,620
‫Agora digamos que mudemos

303
00:15:52,170 --> 00:15:54,300
‫para dois, então devemos ver os

304
00:15:54,300 --> 00:15:56,990
‫dois primeiros com o mesmo tempo, e exatamente,

305
00:15:56,990 --> 00:15:59,710
‫os dois segundos também com um tempo semelhante.

306
00:15:59,710 --> 00:16:01,363
‫Então isso faz sentido, certo.

307
00:16:02,650 --> 00:16:04,500
‫Apenas para completar aqui,

308
00:16:05,610 --> 00:16:08,950
‫agora o mesmo com três, então esses três têm um

309
00:16:08,950 --> 00:16:11,340
‫tempo semelhante e, em seguida, o último.

310
00:16:11,340 --> 00:16:15,440
‫Certo, é assim que o pool de threads funciona basicamente, então decidi

311
00:16:15,440 --> 00:16:18,660
‫não apenas focar no loop de eventos, mas também

312
00:16:18,660 --> 00:16:22,630
‫dar uma visão geral, muito rápida, do pool de threads e

313
00:16:22,630 --> 00:16:25,010
‫como podemos alterar o tamanho do

314
00:16:25,010 --> 00:16:27,620
‫pool de threads Ok, lembre-se de que

315
00:16:27,620 --> 00:16:29,560
‫este código aqui ainda

316
00:16:29,560 --> 00:16:33,230
‫é assíncrono, porque passamos uma função de retorno de chamada.

317
00:16:33,230 --> 00:16:36,490
‫Ok, poderíamos realmente usar a versão síncrona, mas isso

318
00:16:36,490 --> 00:16:38,920
‫bloquearia o loop de eventos.

319
00:16:38,920 --> 00:16:40,650
‫Quer ver isso?

320
00:16:40,650 --> 00:16:43,183
‫Então, deixe-me mostrar isso rapidamente para você também, então

321
00:16:44,120 --> 00:16:46,130
‫aquele não foi realmente planejado, mas

322
00:16:46,130 --> 00:16:48,240
‫vamos fazer assim mesmo, porque é muito

323
00:16:48,240 --> 00:16:50,090
‫interessante ver isso, eu acho.

324
00:16:51,580 --> 00:16:53,830
‫Ok, então isso vai funcionar assim.

325
00:16:53,830 --> 00:16:57,570
‫Usamos novamente a versão de sincronização da mesma função, que

326
00:16:57,570 --> 00:16:59,950
‫uma nota, está muitas vezes disponível.

327
00:16:59,950 --> 00:17:02,760
‫Lembre-se de que temos o mesmo para o arquivo lido,

328
00:17:02,760 --> 00:17:05,190
‫então lemos o arquivo, que aceita um retorno

329
00:17:05,190 --> 00:17:08,290
‫de chamada, e lemos a sincronização de arquivo, que é a

330
00:17:08,290 --> 00:17:11,440
‫versão síncrona que não aceita nenhum retorno de chamada, então assim.

331
00:17:11,440 --> 00:17:13,520
‫Portanto, este irá criptografar a senha,

332
00:17:13,520 --> 00:17:16,890
‫bloquear a execução do código e, em seguida, passar para a

333
00:17:16,890 --> 00:17:19,700
‫próxima linha, que irá registrar isso aqui no console.

334
00:17:19,700 --> 00:17:21,823
‫Então, vamos agora duplicar isso aqui.

335
00:17:23,570 --> 00:17:26,553
‫Isso foi demais, livre-se deste aqui, e

336
00:17:27,500 --> 00:17:31,310
‫agora essas quatro criptografias de senha não serão mais executadas

337
00:17:31,310 --> 00:17:33,350
‫no loop de eventos.

338
00:17:33,350 --> 00:17:37,070
‫E assim eles não serão mais descarregados para o pool de threads.

339
00:17:37,070 --> 00:17:39,980
‫Ok, e agora mesmo se tivermos o tamanho do pool de

340
00:17:39,980 --> 00:17:42,583
‫threads de quatro, vamos ver o que acontece.

341
00:17:46,010 --> 00:17:50,080
‫Então você vê, eles acontecem completamente de forma síncrona.

342
00:17:50,080 --> 00:17:53,290
‫Então, um após o outro, e o que é

343
00:17:53,290 --> 00:17:55,350
‫ainda pior, é que

344
00:17:55,350 --> 00:17:57,960
‫todos esses temporizadores aqui, mesmo nextTick e

345
00:17:57,960 --> 00:18:01,850
‫o imediato, só apareceram depois que as criptografias de senha aconteceram.

346
00:18:01,850 --> 00:18:04,990
‫Então isso realmente estava bloqueando toda a execução, mesmo se

347
00:18:04,990 --> 00:18:07,460
‫este temporizador aqui, por exemplo este aqui, fosse

348
00:18:07,460 --> 00:18:09,580
‫finalizado após zero segundos e este

349
00:18:09,580 --> 00:18:11,440
‫após três segundos, mas

350
00:18:11,440 --> 00:18:13,830
‫todos eles tiveram que esperar sete segundos

351
00:18:13,830 --> 00:18:16,010
‫até que todas essas criptografias de senha

352
00:18:16,010 --> 00:18:19,670
‫aqui fossem finalmente prontos, novamente porque eles não estavam sendo executados

353
00:18:19,670 --> 00:18:22,120
‫dentro do loop de eventos, mas estavam.

354
00:18:22,120 --> 00:18:24,960
‫E então eles estavam basicamente trabalhando em segundo plano

355
00:18:24,960 --> 00:18:26,890
‫e só podiam ser

356
00:18:26,890 --> 00:18:29,470
‫captados pelo loop de eventos quando estavam

357
00:18:29,470 --> 00:18:32,110
‫prontos, logo após essas quatro criptografias de senha,

358
00:18:32,110 --> 00:18:34,760
‫então este foi outro grande exemplo de ver

359
00:18:34,760 --> 00:18:38,240
‫o bloqueio de código e o loop de eventos em ação.

360
00:18:38,240 --> 00:18:41,600
‫Ok, isso foi o suficiente para uma palestra, espero que

361
00:18:41,600 --> 00:18:43,270
‫você tenha achado interessante,

362
00:18:43,270 --> 00:18:45,220
‫e vejo você na próxima.