1
00:00:01,150 --> 00:00:02,580
‫Instructor: Bienvenido de nuevo.

2
00:00:02,580 --> 00:00:05,000
‫Aprendamos ahora todo sobre el bucle de eventos, que

3
00:00:05,000 --> 00:00:08,150
‫es el corazón de Node. js arquitectura.

4
00:00:08,150 --> 00:00:10,580
‫Y esta es probablemente la conferencia

5
00:00:10,580 --> 00:00:13,500
‫más importante de esta sección, así que asegúrese de

6
00:00:13,500 --> 00:00:16,510
‫comprender realmente todo lo que le muestro durante este video.

7
00:00:16,510 --> 00:00:17,813
‫Entonces empecemos.

8
00:00:18,800 --> 00:00:21,880
‫Entonces, aquí hay un diagrama similar al de la

9
00:00:21,880 --> 00:00:25,170
‫última conferencia para que sepamos exactamente de qué estamos hablando aquí.

10
00:00:25,170 --> 00:00:28,240
‫Entonces, todavía estamos en un proceso de nodo en el único hilo

11
00:00:28,240 --> 00:00:30,810
‫donde se ejecuta el ciclo de eventos, ¿de acuerdo?

12
00:00:30,810 --> 00:00:32,530
‫Ahora, lo primero que debe saber

13
00:00:32,530 --> 00:00:34,750
‫es que el bucle de eventos es donde se

14
00:00:34,750 --> 00:00:36,350
‫ejecuta todo el código de

15
00:00:36,350 --> 00:00:39,550
‫la aplicación que está dentro de las funciones de devolución de llamada.

16
00:00:39,550 --> 00:00:43,640
‫Entonces, básicamente, todo el código que no sea de nivel superior se ejecutará

17
00:00:43,640 --> 00:00:45,250
‫en el bucle de eventos.

18
00:00:45,250 --> 00:00:48,450
‫Algunas partes pueden descargarse al grupo de subprocesos como vimos en

19
00:00:48,450 --> 00:00:50,140
‫la última lección, pero es

20
00:00:50,140 --> 00:00:53,430
‫el bucle de eventos el que se encarga de todo esto.

21
00:00:53,430 --> 00:00:56,370
‫Como dije antes, realmente es el corazón

22
00:00:56,370 --> 00:00:58,360
‫de la arquitectura Node.

23
00:00:58,360 --> 00:01:01,660
‫Bien, ahora, como mencioné muchas veces en la primera parte

24
00:01:01,660 --> 00:01:04,300
‫del curso, Node. js se basa en

25
00:01:04,300 --> 00:01:05,860
‫funciones de devolución de llamada.

26
00:01:05,860 --> 00:01:08,160
‫Por lo tanto, funciones que se

27
00:01:08,160 --> 00:01:11,700
‫llaman tan pronto como se termina algún trabajo en el futuro.

28
00:01:11,700 --> 00:01:12,960
‫¿Recuérdalo?

29
00:01:12,960 --> 00:01:15,310
‫Y funciona de esta manera porque Node

30
00:01:15,310 --> 00:01:17,750
‫usa una arquitectura activada por eventos, que

31
00:01:17,750 --> 00:01:20,480
‫es algo de lo que hablaremos en uno

32
00:01:20,480 --> 00:01:22,100
‫de los próximos videos.

33
00:01:22,100 --> 00:01:24,180
‫Pero lo que necesita saber por

34
00:01:24,180 --> 00:01:26,020
‫ahora es que cosas como

35
00:01:26,020 --> 00:01:31,020
‫que nuestra aplicación reciba una solicitud HTTP en nuestro servidor o un temporizador que expire

36
00:01:31,130 --> 00:01:34,860
‫o un archivo que termine de leerse, todos estos emitirán eventos tan

37
00:01:34,860 --> 00:01:37,350
‫pronto como terminen con su trabajo, y nuestro

38
00:01:37,350 --> 00:01:40,150
‫evento. loop luego recogerá estos eventos y llamará

39
00:01:40,150 --> 00:01:41,880
‫a las funciones de

40
00:01:41,880 --> 00:01:44,750
‫devolución de llamada que están asociadas con cada evento.

41
00:01:44,750 --> 00:01:46,520
‫Vale, ¿tiene sentido?

42
00:01:46,520 --> 00:01:49,680
‫Entonces, nuevamente, el bucle de eventos recibe eventos cada vez

43
00:01:49,680 --> 00:01:51,800
‫que sucede algo importante, y luego

44
00:01:51,800 --> 00:01:54,440
‫llamará a las devoluciones de llamada necesarias, como

45
00:01:54,440 --> 00:01:56,443
‫las definimos en nuestro código.

46
00:01:57,300 --> 00:01:59,690
‫Entonces, en resumen, generalmente se dice

47
00:01:59,690 --> 00:02:02,600
‫que el bucle de eventos realiza la orquestación,

48
00:02:02,600 --> 00:02:05,310
‫lo que simplemente significa que recibe eventos, llama

49
00:02:05,310 --> 00:02:07,330
‫a sus funciones de devolución

50
00:02:07,330 --> 00:02:11,290
‫de llamada y descarga las tareas más costosas al grupo de subprocesos.

51
00:02:11,290 --> 00:02:14,670
‫Ahora bien, ¿cómo funciona todo esto detrás de escena?

52
00:02:14,670 --> 00:02:17,960
‫¿En qué orden se ejecutan estas devoluciones de llamada?

53
00:02:17,960 --> 00:02:20,543
‫Bueno, eso es lo que averiguaremos a continuación.

54
00:02:21,460 --> 00:02:24,630
‫Entonces, recuerde, cuando iniciamos nuestra aplicación Node, el ciclo

55
00:02:24,630 --> 00:02:27,430
‫de eventos comienza a ejecutarse de inmediato.

56
00:02:27,430 --> 00:02:29,720
‫Ahora, el bucle de eventos tiene varias fases,

57
00:02:29,720 --> 00:02:32,330
‫y cada fase tiene una cola de devolución de

58
00:02:32,330 --> 00:02:35,060
‫llamada, que son las devoluciones de llamada que provienen de

59
00:02:35,060 --> 00:02:36,690
‫los eventos que recibe

60
00:02:36,690 --> 00:02:39,830
‫el bucle de eventos, tal como hablamos en la última diapositiva.

61
00:02:39,830 --> 00:02:41,830
‫Ahora, en algunos lugares leerá que

62
00:02:41,830 --> 00:02:45,520
‫solo hay una cola de devolución de llamada o una cola de eventos,

63
00:02:45,520 --> 00:02:49,290
‫pero de hecho, como dije, el ciclo de eventos tiene muchas fases en las

64
00:02:49,290 --> 00:02:52,290
‫que cada fase tiene su propia cola de devolución de llamada.

65
00:02:52,290 --> 00:02:56,090
‫Entonces, ahora echemos un vistazo a las cuatro fases más importantes.

66
00:02:56,090 --> 00:02:58,090
‫Hay una o dos fases más que

67
00:02:58,090 --> 00:02:59,890
‫Node usa internamente, pero estas

68
00:02:59,890 --> 00:03:01,360
‫no son tan importantes

69
00:03:01,360 --> 00:03:03,530
‫y no voy a hablar de ellas.

70
00:03:03,530 --> 00:03:05,230
‫Entonces, la primera fase

71
00:03:05,230 --> 00:03:07,860
‫se encarga de las devoluciones de llamada de

72
00:03:07,860 --> 00:03:10,880
‫los temporizadores caducados, por ejemplo, desde la función setTimeout ().

73
00:03:10,880 --> 00:03:13,210
‫Entonces, si hay funciones de devolución de llamada de

74
00:03:13,210 --> 00:03:15,750
‫temporizadores que acaban de expirar, estas son las primeras en

75
00:03:15,750 --> 00:03:18,010
‫ser procesadas por el bucle de eventos.

76
00:03:18,010 --> 00:03:21,040
‫Si un temporizador expira más tarde durante el tiempo en que

77
00:03:21,040 --> 00:03:23,370
‫se está procesando una de las otras

78
00:03:23,370 --> 00:03:26,860
‫fases, bueno, entonces la devolución de llamada de ese temporizador solo se

79
00:03:26,860 --> 00:03:30,450
‫llamará tan pronto como el bucle de eventos vuelva a esta primera fase.

80
00:03:30,450 --> 00:03:31,580
‫¿Tener sentido?

81
00:03:31,580 --> 00:03:34,520
‫Y funciona así en las cuatro fases.

82
00:03:34,520 --> 00:03:37,250
‫Por lo tanto, las devoluciones de llamada en cada

83
00:03:37,250 --> 00:03:40,810
‫cola se procesan una por una hasta que no quedan nadie en

84
00:03:40,810 --> 00:03:44,630
‫la cola, y solo entonces, el bucle de eventos entrará en la siguiente fase.

85
00:03:44,630 --> 00:03:49,180
‫A continuación, tenemos el sondeo de E / S y la ejecución de devoluciones de llamada de E / S.

86
00:03:49,180 --> 00:03:52,840
‫Y nuevamente, recuerde que E / S significa entrada / salida.

87
00:03:52,840 --> 00:03:56,040
‫Entonces, el sondeo básicamente significa buscar nuevos eventos de E /

88
00:03:56,040 --> 00:03:58,060
‫S que estén listos para ser

89
00:03:58,060 --> 00:04:00,890
‫procesados y ponerlos en la cola de devolución de llamada.

90
00:04:00,890 --> 00:04:04,110
‫Y recuerde que en el contexto de una aplicación Node,

91
00:04:04,110 --> 00:04:08,710
‫E / S significa principalmente cosas como redes y acceso a archivos, por lo que

92
00:04:08,710 --> 00:04:12,150
‫es en esta fase donde probablemente se ejecuta el 99% de

93
00:04:12,150 --> 00:04:14,270
‫nuestro código, simplemente porque en

94
00:04:14,270 --> 00:04:16,640
‫una aplicación Node típica, la mayor parte

95
00:04:16,640 --> 00:04:20,500
‫de lo que tenemos que hacer está relacionado con la creación de

96
00:04:20,500 --> 00:04:23,170
‫redes y también con el acceso a archivos.

97
00:04:23,170 --> 00:04:26,490
‫La siguiente fase es para las devoluciones de llamada de setImmediate,

98
00:04:26,490 --> 00:04:29,250
‫y setImmediate es un tipo especial de temporizador que

99
00:04:29,250 --> 00:04:32,810
‫podemos usar si queremos procesar las devoluciones de llamada inmediatamente después de

100
00:04:32,810 --> 00:04:36,130
‫la fase de ejecución y sondeo de E / S, que

101
00:04:36,130 --> 00:04:39,173
‫puede ser importante en algunos casos de uso más avanzados.

102
00:04:40,110 --> 00:04:40,943
‫Está bien.

103
00:04:40,943 --> 00:04:44,940
‫Y finalmente, la cuarta fase es para devoluciones de llamada cercanas, que,

104
00:04:44,940 --> 00:04:47,530
‫de nuevo, no son tan importantes para

105
00:04:47,530 --> 00:04:50,820
‫nosotros, pero de todos modos pongo esto aquí para completarlo.

106
00:04:50,820 --> 00:04:54,450
‫Básicamente, en esta fase, todos los eventos cercanos se

107
00:04:54,450 --> 00:04:58,920
‫procesan, por ejemplo, cuando se apaga un servidor web o un WebSocket.

108
00:04:58,920 --> 00:05:01,920
‫Entonces, estas son las cuatro fases en el bucle

109
00:05:01,920 --> 00:05:05,400
‫de eventos, pero además de estas cuatro colas de devolución de

110
00:05:05,400 --> 00:05:08,330
‫llamada que acabamos de ver, en realidad también

111
00:05:08,330 --> 00:05:11,600
‫hay otras dos colas, la cola nextTick () y la

112
00:05:11,600 --> 00:05:14,780
‫cola de otras microtasks, que es principalmente para promesas resueltas.

113
00:05:14,780 --> 00:05:16,890
‫Si no está familiarizado con las

114
00:05:16,890 --> 00:05:20,240
‫promesas, hablaremos un poco sobre ellas en una sección posterior.

115
00:05:20,240 --> 00:05:22,620
‫De todos modos, si hay devoluciones de llamada

116
00:05:22,620 --> 00:05:24,750
‫en una de estas dos colas para

117
00:05:24,750 --> 00:05:27,840
‫ser procesadas, se ejecutarán justo después de que finalice la fase

118
00:05:27,840 --> 00:05:30,250
‫actual del bucle de eventos en lugar de

119
00:05:30,250 --> 00:05:32,380
‫esperar a que termine todo el bucle.

120
00:05:32,380 --> 00:05:33,370
‫¿Okey?

121
00:05:33,370 --> 00:05:36,680
‫Entonces, en otras palabras, después de cada una de

122
00:05:36,680 --> 00:05:40,340
‫estas cuatro fases, si hay devoluciones de llamada en estas dos

123
00:05:40,340 --> 00:05:42,880
‫colas especiales, se ejecutarán de inmediato.

124
00:05:42,880 --> 00:05:46,030
‫Ahora, por ejemplo, imagine que una promesa se resuelve y

125
00:05:46,030 --> 00:05:49,730
‫devuelve algunos datos de una llamada a la API mientras se está

126
00:05:49,730 --> 00:05:52,690
‫ejecutando la devolución de llamada de un temporizador caducado.

127
00:05:52,690 --> 00:05:56,050
‫Entonces, en este caso, la devolución de llamada de promesa se

128
00:05:56,050 --> 00:05:59,230
‫ejecutará justo después de que finalice la del temporizador.

129
00:05:59,230 --> 00:06:00,490
‫¿Okey?

130
00:06:00,490 --> 00:06:03,480
‫Y la misma lógica también se aplica a la cola nextTick (),

131
00:06:03,480 --> 00:06:05,290
‫de la que aún no hablamos.

132
00:06:05,290 --> 00:06:09,060
‫Entonces, básicamente, procesar nextTick () es una función que podemos usar

133
00:06:09,060 --> 00:06:11,610
‫cuando realmente, realmente necesitamos ejecutar una determinada devolución

134
00:06:11,610 --> 00:06:13,740
‫de llamada justo después de

135
00:06:13,740 --> 00:06:16,290
‫la fase de bucle de eventos actual.

136
00:06:16,290 --> 00:06:18,810
‫Es un poco similar a setImmediate, con la diferencia de

137
00:06:18,810 --> 00:06:21,540
‫que setImmediate solo se ejecuta después de la fase de devolución

138
00:06:21,540 --> 00:06:23,400
‫de llamada de E / S.

139
00:06:23,400 --> 00:06:24,600
‫Sin embargo, lo

140
00:06:24,600 --> 00:06:27,930
‫que es similar es que ambos son para casos de uso realmente

141
00:06:27,930 --> 00:06:30,080
‫avanzados, y probablemente ni siquiera los necesitemos a

142
00:06:30,080 --> 00:06:31,580
‫lo largo de este curso.

143
00:06:31,580 --> 00:06:34,660
‫Pero de todos modos, también quería incluir este material

144
00:06:34,660 --> 00:06:36,700
‫más complejo aquí para que tenga

145
00:06:36,700 --> 00:06:38,940
‫las herramientas que necesita si realmente

146
00:06:38,940 --> 00:06:42,980
‫necesita profundizar en Node. js si quieres.

147
00:06:42,980 --> 00:06:46,210
‫Muy bien, y con eso, en realidad terminamos un

148
00:06:46,210 --> 00:06:50,360
‫tic del ciclo de eventos, y un tic es básicamente un ciclo

149
00:06:50,360 --> 00:06:51,580
‫en este ciclo.

150
00:06:51,580 --> 00:06:54,840
‫Entonces, ahora es el momento de decidir si el ciclo

151
00:06:54,840 --> 00:06:58,520
‫debe continuar hasta el siguiente tick o si el programa debe salir.

152
00:06:58,520 --> 00:07:00,720
‫¿Y cómo lo hace Node?

153
00:07:00,720 --> 00:07:02,310
‫Bueno, es muy simple.

154
00:07:02,310 --> 00:07:05,100
‫El nodo simplemente verifica si hay temporizadores o

155
00:07:05,100 --> 00:07:08,440
‫tareas de E / S que aún se estén ejecutando

156
00:07:08,440 --> 00:07:12,180
‫en segundo plano, y si no hay ninguno, saldrá de la aplicación.

157
00:07:12,180 --> 00:07:15,430
‫Pero si hay temporizadores o tareas de E / S

158
00:07:15,430 --> 00:07:17,870
‫pendientes, bueno, continuará ejecutando el ciclo

159
00:07:17,870 --> 00:07:20,500
‫de eventos e irá directamente al siguiente tick.

160
00:07:20,500 --> 00:07:22,030
‫Entonces, por ejemplo, cuando escuchamos

161
00:07:22,030 --> 00:07:24,740
‫solicitudes HTTP entrantes como lo hicimos en nuestro proyecto de

162
00:07:24,740 --> 00:07:27,770
‫granja de nodos en una sección anterior, básicamente estábamos ejecutando una

163
00:07:27,770 --> 00:07:30,600
‫tarea de E / S, y es por eso que

164
00:07:30,600 --> 00:07:32,320
‫el bucle de eventos y, por

165
00:07:32,320 --> 00:07:34,640
‫lo tanto, Node. js, siga

166
00:07:34,640 --> 00:07:38,600
‫ejecutándose y siga escuchando las nuevas solicitudes HTTP que ingresan

167
00:07:38,600 --> 00:07:41,920
‫en lugar de simplemente salir de la aplicación.

168
00:07:41,920 --> 00:07:44,450
‫Además, cuando escribimos o leemos un archivo

169
00:07:44,450 --> 00:07:47,480
‫en segundo plano, también es una tarea de E /

170
00:07:47,480 --> 00:07:50,210
‫S, por lo que tiene sentido que la aplicación

171
00:07:50,210 --> 00:07:53,260
‫no se cierre mientras está trabajando con ese archivo, ¿verdad?

172
00:07:53,260 --> 00:07:55,780
‫De acuerdo, y esto es básicamente lo que debes

173
00:07:55,780 --> 00:07:57,930
‫saber sobre Node. bucle de eventos js.

174
00:07:57,930 --> 00:08:00,260
‫Si necesita aún más detalles que esto, bueno,

175
00:08:00,260 --> 00:08:01,760
‫siempre puede intentar leer

176
00:08:01,760 --> 00:08:04,860
‫la documentación oficial de Node, que debería ser bastante fácil

177
00:08:04,860 --> 00:08:07,060
‫de entender en este punto ahora que

178
00:08:07,060 --> 00:08:10,570
‫ya comprende la mayor parte del ciclo de eventos de todos modos.

179
00:08:10,570 --> 00:08:12,830
‫Y solo quiero enfatizar que es

180
00:08:12,830 --> 00:08:15,940
‫realmente muy importante para usted comprender correctamente el ciclo de

181
00:08:15,940 --> 00:08:18,280
‫eventos para que pueda escribir su propio

182
00:08:18,280 --> 00:08:21,390
‫código de ejecución y también depurar su propio código

183
00:08:21,390 --> 00:08:24,173
‫cuando algo sale mal de una manera inesperada.

184
00:08:25,720 --> 00:08:27,770
‫Y ahora, para terminar, repasemos algunas de las

185
00:08:27,770 --> 00:08:29,810
‫cosas de las que hablamos aquí.

186
00:08:29,810 --> 00:08:32,490
‫Entonces, en pocas palabras, lo más importante que quiero que

187
00:08:32,490 --> 00:08:34,620
‫comprendan de esta conferencia, y tal vez de

188
00:08:34,620 --> 00:08:36,740
‫todo este curso, es que el bucle de

189
00:08:36,740 --> 00:08:38,560
‫eventos es lo que hace posible

190
00:08:38,560 --> 00:08:41,630
‫la programación asincrónica en Node. js, lo que la convierte

191
00:08:41,630 --> 00:08:45,190
‫en la característica más importante en el diseño de Node y

192
00:08:45,190 --> 00:08:47,580
‫hace que Node. js completamente

193
00:08:47,580 --> 00:08:49,050
‫diferente a otras plataformas.

194
00:08:49,050 --> 00:08:51,600
‫Se encarga de todos los eventos entrantes

195
00:08:51,600 --> 00:08:55,120
‫y realiza la orquestación descargando tareas más pesadas en el

196
00:08:55,120 --> 00:08:58,840
‫grupo de subprocesos y haciendo el trabajo más simple por sí mismo.

197
00:08:58,840 --> 00:09:01,520
‫Además, recuerde que necesitamos el ciclo de

198
00:09:01,520 --> 00:09:05,260
‫eventos porque en Node. js todo funciona en un

199
00:09:05,260 --> 00:09:07,260
‫solo hilo, por lo que puede

200
00:09:07,260 --> 00:09:11,230
‫tener miles o millones de usuarios accediendo al mismo hilo al mismo tiempo.

201
00:09:11,230 --> 00:09:13,690
‫Esto hace que Node sea tan liviano y

202
00:09:13,690 --> 00:09:16,290
‫escalable, pero al mismo tiempo, conlleva el peligro

203
00:09:16,290 --> 00:09:17,930
‫de bloquear nuestro único

204
00:09:17,930 --> 00:09:20,140
‫hilo, lo que ralentizaría toda la

205
00:09:20,140 --> 00:09:25,140
‫aplicación o incluso se detendría para que todos sus usuarios accedan a la aplicación, ¿verdad?

206
00:09:25,340 --> 00:09:28,110
‫Ahora, en otros lenguajes como PHP que

207
00:09:28,110 --> 00:09:31,300
‫se ejecuta en un servidor Apache, básicamente, se crea

208
00:09:31,300 --> 00:09:35,200
‫un nuevo hilo para cada nuevo usuario, lo que consume más recursos.

209
00:09:35,200 --> 00:09:37,180
‫Pero por otro lado, no

210
00:09:37,180 --> 00:09:39,160
‫hay peligro de bloqueo, ¿verdad?

211
00:09:39,160 --> 00:09:41,430
‫Entonces, todo ese modelo hace que sea

212
00:09:41,430 --> 00:09:44,340
‫un poco más fácil de usar PHP para principiantes, pero

213
00:09:44,340 --> 00:09:46,540
‫por supuesto, tiene sus propias desventajas,

214
00:09:46,540 --> 00:09:48,890
‫que no voy a profundizar en este punto.

215
00:09:48,890 --> 00:09:50,690
‫De todos modos, permítame

216
00:09:50,690 --> 00:09:54,860
‫recordarle nuevamente que es su responsabilidad no bloquear el bucle de eventos, por

217
00:09:54,860 --> 00:09:58,150
‫lo que aquí hay un par de pautas para eso.

218
00:09:58,150 --> 00:10:00,490
‫En primer lugar, no use las versiones

219
00:10:00,490 --> 00:10:02,850
‫de sincronización de funciones en los módulos fs,

220
00:10:02,850 --> 00:10:06,450
‫crypto o zlib en sus funciones de devolución de llamada, ¿de acuerdo?

221
00:10:06,450 --> 00:10:09,210
‫Entonces, en nuestro primer proyecto, usamos la versión síncrona,

222
00:10:09,210 --> 00:10:12,610
‫pero estaba en el código de nivel superior, por lo que

223
00:10:12,610 --> 00:10:15,000
‫fuera de cualquier devolución de llamada.

224
00:10:15,000 --> 00:10:18,520
‫Y dado que ese código se ejecuta incluso antes de que comience

225
00:10:18,520 --> 00:10:22,200
‫el bucle de eventos, bueno, no es un problema usar la versión síncrona allí.

226
00:10:22,200 --> 00:10:24,910
‫Además, y esto probablemente sea bastante obvio,

227
00:10:24,910 --> 00:10:28,140
‫no realice cálculos muy complejos en el ciclo de eventos.

228
00:10:28,140 --> 00:10:29,730
‫Entonces, cosas como procesar

229
00:10:29,730 --> 00:10:33,890
‫millones de números en bucles dentro de bucles, o algo así.

230
00:10:33,890 --> 00:10:37,550
‫A continuación, tenga cuidado con JSON en objetos muy grandes

231
00:10:37,550 --> 00:10:40,480
‫porque, en algún momento, puede comenzar

232
00:10:40,480 --> 00:10:43,440
‫a tomar mucho tiempo analizar o secuenciar JSON.

233
00:10:43,440 --> 00:10:47,170
‫Y, por último, no utilice expresiones regulares demasiado complejas,

234
00:10:47,170 --> 00:10:49,840
‫por ejemplo, con varios cuantificadores anidados

235
00:10:49,840 --> 00:10:52,130
‫o referencias inversas, porque de

236
00:10:52,130 --> 00:10:54,810
‫nuevo, pueden tardar más de lo esperado.

237
00:10:54,810 --> 00:10:56,680
‫Estas son, por supuesto, solo un par

238
00:10:56,680 --> 00:10:59,700
‫de pautas de alto nivel, pero lo ayudarán a comenzar en

239
00:10:59,700 --> 00:11:00,803
‫el camino correcto.

240
00:11:01,650 --> 00:11:03,490
‫Ahora, existen algunas soluciones potenciales

241
00:11:03,490 --> 00:11:06,390
‫a estos problemas de bloqueo, como la descarga manual al

242
00:11:06,390 --> 00:11:09,750
‫grupo de subprocesos o el uso de procesos secundarios, y podríamos

243
00:11:09,750 --> 00:11:12,070
‫hablar de esto al final del curso

244
00:11:12,070 --> 00:11:14,370
‫o en algún momento en el futuro,

245
00:11:14,370 --> 00:11:17,460
‫pero por ahora, es importante que entiende y sigue este

246
00:11:17,460 --> 00:11:20,110
‫consejo de no bloquear realmente el ciclo de eventos.

247
00:11:20,110 --> 00:11:21,600
‫Está bien.

248
00:11:21,600 --> 00:11:24,520
‫A continuación, les daré un pequeño ejemplo para mostrarles algunas

249
00:11:24,520 --> 00:11:25,990
‫de las cosas de

250
00:11:25,990 --> 00:11:27,640
‫las que hablamos en la práctica.