1
00:00:00,120 --> 00:00:00,780
Continuamos.

2
00:00:00,810 --> 00:00:03,730
Cuando enviamos una tarea a ejecución con el submit.

3
00:00:03,960 --> 00:00:08,310
Bueno, lo que podría devolver es un objeto del tipo feúcha.

4
00:00:08,580 --> 00:00:12,150
O futuro, que es una representación de esta tarea que se está ejecutando.

5
00:00:12,300 --> 00:00:17,130
Y podemos realizar un rastreo, una trazabilidad de esta tarea que está en ejecución.

6
00:00:17,250 --> 00:00:19,350
Por ejemplo, la podemos cancelar.

7
00:00:19,440 --> 00:00:23,670
Podemos saber si ha finalizado o si está en ejecución o si ha sido cancelada.

8
00:00:23,730 --> 00:00:24,900
En fin, un montón de cosas.

9
00:00:25,020 --> 00:00:28,710
Y también podría devolver un valor, retornar un resultado final.

10
00:00:28,770 --> 00:00:33,210
Esta tarea también la podríamos obtener con este objeto futuro.

11
00:00:33,300 --> 00:00:38,820
Recuerden, entonces representa un resultado futuro de esta operación asíncrona.

12
00:00:38,940 --> 00:00:46,190
Dependiendo si es rentable la tarea o cable podría devolver un resultado y este resultado podría aparecer.

13
00:00:46,380 --> 00:00:52,170
Pero después, una vez que se procese y se termine la tarea en el futuro, entonces por eso es el tipo

14
00:00:52,170 --> 00:00:53,160
de dato futuro.

15
00:00:53,370 --> 00:00:56,250
Veamos el ejemplo para no modificar esto que tenemos.

16
00:00:56,550 --> 00:00:58,290
Voy a cerrar y voy a copiar.

17
00:00:58,360 --> 00:01:00,120
Ejemplo executar.

18
00:01:00,510 --> 00:01:02,580
Lo pegamos y vamos a colocar acá.

19
00:01:02,850 --> 00:01:03,350
Fouché.

20
00:01:04,390 --> 00:01:07,200
Ok, bien, vamos a quitar esto.

21
00:01:07,860 --> 00:01:08,610
Lo eliminamos.

22
00:01:09,060 --> 00:01:12,210
Dejamos solamente continuando con la operación del método Main.

23
00:01:13,350 --> 00:01:15,780
Vamos a trabajar con el futuro, pero esto es geto.

24
00:01:15,870 --> 00:01:17,280
Lo tenemos a través del zumbido.

25
00:01:17,490 --> 00:01:21,150
El submit devuélvete sugeto una representación futura de la tarea.

26
00:01:21,180 --> 00:01:25,410
Entonces futura of voucher maneja también tipo de auto genérico.

27
00:01:25,620 --> 00:01:29,550
Como es del tipo razonable, la tarea no devuelve nada.

28
00:01:29,610 --> 00:01:30,670
Por lo tanto, vamos a colocarnos.

29
00:01:30,670 --> 00:01:39,990
Si no pregunta acá me comí el ejecutor y acá en nombre de le vamos a colocar un resultado resultado

30
00:01:40,350 --> 00:01:44,310
un resultado futuro de la tarea bien y filter se importa.

31
00:01:44,370 --> 00:01:47,550
Recuerden de lleba útil concurrente.

32
00:01:48,150 --> 00:01:55,470
Bien y acá vamos a imprimir shout resultado futuro en realidad.

33
00:01:55,500 --> 00:01:56,430
Punto.

34
00:01:56,460 --> 00:01:59,430
Acá tenemos el método I'S donde se ha terminado.

35
00:01:59,610 --> 00:02:02,890
También tenemos si ha sido cancelado, podemos cancelar esta tarea.

36
00:02:03,420 --> 00:02:09,510
Y con qué podemos obtener el valor futuro o el resultado futuro que eventualmente podría retornar?

37
00:02:09,510 --> 00:02:15,390
La tarea dependiendo cierra nivel no retorna nada, pero si es escalable va a retornar un valor.

38
00:02:15,900 --> 00:02:17,520
Bien, vamos a colocar Down.

39
00:02:18,000 --> 00:02:18,840
Si ha finalizado.

40
00:02:19,200 --> 00:02:20,010
Pero por supuesto que no!

41
00:02:20,040 --> 00:02:20,500
Por qué?

42
00:02:20,690 --> 00:02:22,910
Recuerden que tienen un delay de 5 segundos.

43
00:02:23,130 --> 00:02:25,110
Voy a cambiar a 3 para que no sea tanto.

44
00:02:25,320 --> 00:02:25,810
Entonces qué a.

45
00:02:26,250 --> 00:02:28,530
Voy a ejecutar lo primero que se imprime.

46
00:02:28,680 --> 00:02:35,250
Continuando con la ejecución del método Main, después imprime is down falso y comienza la tarea porque

47
00:02:35,250 --> 00:02:36,330
tiene ese pequeño delay.

48
00:02:36,450 --> 00:02:39,300
Entonces va a mostrar inicio la tarea y todo lo demás.

49
00:02:39,390 --> 00:02:40,320
Nombre del Dredd.

50
00:02:40,740 --> 00:02:41,970
Y después finaliza la tarea.

51
00:02:42,180 --> 00:02:42,840
Vamos a probar.

52
00:02:46,340 --> 00:02:49,030
Se fijan, continuando con la ejecución de me tomé fols.

53
00:02:49,910 --> 00:02:56,000
Por lo tanto no ha finalizado, ya que está recién comenzando la tarea con este delay de 3 segundos.

54
00:02:57,820 --> 00:03:01,570
Bien, pero también podría obtener este valor futuro independientes en Nul.

55
00:03:01,660 --> 00:03:03,520
En el caso del ranees, recuerden que null.

56
00:03:03,610 --> 00:03:11,050
Por lo tanto, si imprimo acá el shout resultado, punto, nyet, va a retornar un null.

57
00:03:11,290 --> 00:03:18,010
Acá me pide manejar el trait catch dos excepciones Interruptor Deception y también execute en Exception

58
00:03:18,160 --> 00:03:19,310
estas dos excepciones.

59
00:03:19,360 --> 00:03:24,610
Entonces puedes se contradic catch o se declaran en el método vamos a colocar declarar en el método.

60
00:03:25,600 --> 00:03:28,900
Acá tenemos las dos intercepte y execucion excepto.

61
00:03:30,700 --> 00:03:30,940
Bien.

62
00:03:31,030 --> 00:03:31,910
Pero qué hace el Quiete?

63
00:03:32,110 --> 00:03:33,460
El nyet, hay que tener cuidado.

64
00:03:33,640 --> 00:03:37,270
No siempre es bueno llamarlo porque bloquea el dirig actual.

65
00:03:37,390 --> 00:03:41,650
Quien espera hasta que se ejecute la tarea, finalice y devuelva el valor.

66
00:03:42,190 --> 00:03:44,980
Claro, por poner un ejemplo, para que lo vean visualmente.

67
00:03:45,130 --> 00:03:46,690
Voy a imprimir otra cosa.

68
00:03:46,720 --> 00:03:50,080
Shout continuamos.

69
00:03:51,400 --> 00:03:52,180
Entonces, qué va a pasar?

70
00:03:52,280 --> 00:03:53,440
Bueno, voy a imprimir.

71
00:03:53,500 --> 00:03:56,020
Continuando con la ejecución del método Main.

72
00:03:56,380 --> 00:03:57,160
Falso.

73
00:03:57,310 --> 00:03:58,540
Acá invoca al Gillet.

74
00:03:58,570 --> 00:04:00,580
Por lo tanto obtiene el resultado.

75
00:04:00,670 --> 00:04:02,920
Pero como no devuelve nada, va a imprimir null.

76
00:04:03,250 --> 00:04:04,120
Y acá se bloquea.

77
00:04:04,240 --> 00:04:07,720
Acá se da bloquear durante tres segundos hasta que finaliza la tarea.

78
00:04:08,200 --> 00:04:11,760
Y después de imprimir todo inicio de tarea en nombre del Dredd.

79
00:04:11,770 --> 00:04:14,200
Finaliza la tarea después de finalizar la tarea.

80
00:04:14,320 --> 00:04:14,810
Imprime.

81
00:04:14,830 --> 00:04:15,460
Continuamos.

82
00:04:15,580 --> 00:04:18,640
Por qué queda bloqueado el método Main con el nyet?

83
00:04:18,790 --> 00:04:19,450
Lo bloquea.

84
00:04:19,630 --> 00:04:20,260
Por así decir.

85
00:04:20,260 --> 00:04:21,310
Syria como similar.

86
00:04:21,370 --> 00:04:24,100
Se acuerdan al método GEIN del Drizzt?

87
00:04:24,220 --> 00:04:27,340
Que en el fondo el thread principal que está ejecutando otro Drizzt.

88
00:04:27,430 --> 00:04:29,050
Espera a que finalice ese adrid.

89
00:04:29,230 --> 00:04:30,670
Bueno, acá pasa algo similar.

90
00:04:30,850 --> 00:04:33,310
Espere a que finalice y que devuelva el resultado.

91
00:04:33,970 --> 00:04:34,480
Vamos a ver.

92
00:04:34,600 --> 00:04:34,900
Entonces.

93
00:04:34,900 --> 00:04:37,220
El último que retorna o que imprime consola.

94
00:04:37,450 --> 00:04:38,260
Continuamos.

95
00:04:40,790 --> 00:04:42,410
Se fijan en la tarea?

96
00:04:42,620 --> 00:04:43,700
Finaliza la tarea.

97
00:04:43,830 --> 00:04:47,570
Nul porque no devuelve nada y continuamos.

98
00:04:48,020 --> 00:04:51,560
Pero acá se da una pausa porque bloquea el drid o el método Main.

99
00:04:51,860 --> 00:04:53,420
Ahora, qué pasa si colocamos esto acá?

100
00:04:56,290 --> 00:04:58,480
Bueno sea imprimir esto primero.

101
00:04:58,720 --> 00:04:59,530
Después fols.

102
00:04:59,680 --> 00:05:00,730
Y después continuamos.

103
00:05:00,820 --> 00:05:02,530
Y después comienza la tarea.

104
00:05:07,370 --> 00:05:15,230
Pontifican continuamos continuando con la tarea fols continuamos y después comienza la tarea finaliza

105
00:05:15,350 --> 00:05:18,380
y acá se bloquea, se bloquea hasta obtener el nul.

106
00:05:18,590 --> 00:05:19,130
El resultado.

107
00:05:19,450 --> 00:05:20,840
Bien, esto ya lo voy a quitar.

108
00:05:24,830 --> 00:05:26,960
Хотя resultado.

109
00:05:26,990 --> 00:05:28,500
Punto I.

110
00:05:28,880 --> 00:05:29,160
II.

111
00:05:31,030 --> 00:05:33,640
Ahora estás defaults y te a thru?

112
00:05:33,730 --> 00:05:38,550
Claro, porque el gillet espera a que finalice y acá después del nyet va a haber finalizado.

113
00:05:47,520 --> 00:05:49,800
Entonces fols con el jet?

114
00:05:50,070 --> 00:05:50,700
Espera.

115
00:05:50,850 --> 00:05:53,850
Bloquea el main hasta que finaliza la tarea.

116
00:05:53,970 --> 00:05:54,840
Comienza.

117
00:05:54,900 --> 00:05:55,680
Se ejecuta.

118
00:05:55,710 --> 00:05:56,640
Finaliza.

119
00:05:57,090 --> 00:05:58,530
Retorna el resultado.

120
00:05:58,530 --> 00:06:01,260
Nul y Thru ha terminado.

121
00:06:01,440 --> 00:06:04,890
Bien, el nyet también acepta un parámetro, un time out.

122
00:06:05,100 --> 00:06:08,940
Acá se demora 3 segundos y puede colocar un auto.

123
00:06:09,030 --> 00:06:12,210
Por ejemplo, no se puede demorar más de dos segundos en ejecutar la tarea.

124
00:06:12,480 --> 00:06:16,860
Y si se demora más de dos segundos, bueno, que lance una acepción de time out.

125
00:06:16,950 --> 00:06:21,360
Un error time y unit punto secondo.

126
00:06:22,830 --> 00:06:25,020
Y acá nos pide manejar otra acepción.

127
00:06:25,260 --> 00:06:25,920
Una tercera.

128
00:06:26,980 --> 00:06:32,920
El timeout exceptúan puede lanzar esta excepción en caso de que se cumpla el tiempo de Time out.

129
00:06:32,980 --> 00:06:36,580
Primero, antes que finalice la ejecución de la tarea.

130
00:06:36,820 --> 00:06:41,190
Bueno, si esto lo ejecuto, por supuesto que queda lanzar un error solamente para que lo vean nada

131
00:06:41,200 --> 00:06:41,470
más.

132
00:06:43,860 --> 00:06:50,040
Se muere más del tiempo y lanza esta sección de Time out Time Out, excepto ahora.

133
00:06:50,100 --> 00:06:52,140
Por supuesto, si lo colocamos, no sé.

134
00:06:52,230 --> 00:06:52,890
5.

135
00:06:53,340 --> 00:06:58,110
Hoy no hay problema porque se demoran menos en ejecutar la tarea y el tiempo espera en mayor.

136
00:06:58,350 --> 00:07:04,200
Bueno, esto es útil cuando una tarea se pueden ver en mucho, mucho rato y queremos evitar un bloqueo

137
00:07:04,440 --> 00:07:07,290
o que el usuario esté esperando que finalice un proceso.

138
00:07:07,470 --> 00:07:09,000
Quién no debería de tomar mucho tiempo?

139
00:07:09,100 --> 00:07:10,710
Entonces, si se demoran más de la cuenta?

140
00:07:10,770 --> 00:07:11,940
Bueno, lanzar el error.

141
00:07:13,140 --> 00:07:15,810
Bien, vamos a probar acá.

142
00:07:15,870 --> 00:07:17,610
Debería funcionar bien, sin error.

143
00:07:18,820 --> 00:07:24,730
Se fijan y finalizaban porque les dimos más tiempo al time out, qué más bien acabo de comentar esto.

144
00:07:26,170 --> 00:07:28,720
Íbamos a ver otra forma con un quail, claro.

145
00:07:28,750 --> 00:07:29,980
Podríamos ser un wile.

146
00:07:30,310 --> 00:07:35,050
Es decir, mientras no haya finalizado con un distinto resultado.

147
00:07:35,080 --> 00:07:36,960
Punto es donde.

148
00:07:37,390 --> 00:07:41,290
Es decir, mientras no haya finalizado Shout.

149
00:07:44,950 --> 00:07:51,940
Ejecutando tarea y acá podríamos hacer un loop para que nos imprima tantas veces ejecutando tareas.

150
00:07:52,000 --> 00:07:56,770
Por qué está preguntando el Weill constantemente, varias veces hasta que haya finalizado el proceso.

151
00:07:57,010 --> 00:08:06,370
Entonces, como se muera 3 segundos acá podríamos hacer un sleep, un time y unit 1 second punto sleep,

152
00:08:07,180 --> 00:08:12,250
por ejemplo, de 1500 milisegundos, es decir, de la mitad.

153
00:08:13,090 --> 00:08:14,260
Vamos a levantar.

154
00:08:14,500 --> 00:08:17,470
Bueno, debería imprimir como 3 veces ejecutando tarea.

155
00:08:17,680 --> 00:08:17,970
Por qué?

156
00:08:18,010 --> 00:08:19,840
Bueno, primero va a imprimir.

157
00:08:19,870 --> 00:08:25,330
Continuando con la ejecución del método Main, lo primero que se imprime, después entra al while y

158
00:08:25,330 --> 00:08:26,980
entremedio empieza a ejecutar la tarea.

159
00:08:27,070 --> 00:08:33,670
Pero es probable que lo primero que se imprima ejecutando tarea como hace una pausa, se imprime iniciando

160
00:08:33,670 --> 00:08:36,010
la tarea o inicio de tarea en nombre del try.

161
00:08:36,100 --> 00:08:37,420
Acaso una pausa de tres.

162
00:08:38,050 --> 00:08:41,140
Después vuelve a iterar después de 1500.

163
00:08:41,410 --> 00:08:41,860
Perdón.

164
00:08:42,010 --> 00:08:43,120
Acá es segundos.

165
00:08:43,300 --> 00:08:43,660
Perdón.

166
00:08:43,870 --> 00:08:45,340
Voy a colocar milisegundos.

167
00:08:45,490 --> 00:08:49,630
Sí, porque no son 1500 segundos, sino 1,5 segundos.

168
00:08:49,990 --> 00:08:51,880
Entonces voy a cambiar a milisegundos.

169
00:08:52,090 --> 00:08:57,820
En este caso, para que sea más preciso milisegundos que sería 1,5 segundos.

170
00:08:57,910 --> 00:09:02,950
A ese entonces va a estar imprimiendo esto entremedio de que se está ejecutando la tarea.

171
00:09:04,150 --> 00:09:06,310
Y después, cuando finaliza, se sale del huai.

172
00:09:06,430 --> 00:09:07,990
Por lo tanto, acá se queda bloqueado.

173
00:09:08,080 --> 00:09:08,800
Es importante.

174
00:09:08,920 --> 00:09:12,970
Acá queda bloqueado con el sleep hasta que finaliza.

175
00:09:13,060 --> 00:09:17,680
Y cuando finaliza se sale del cual ya terminó y continúa con el quieto.

176
00:09:17,740 --> 00:09:19,340
Por lo tanto, imprime el quiete.

177
00:09:19,630 --> 00:09:24,250
Esto ya no sería necesario porque lo obtiene de forma automática e inmediata, ya que va a imprimir

178
00:09:24,280 --> 00:09:24,540
true.

179
00:09:24,640 --> 00:09:26,110
Por supuesto, porque ya finalizó.

180
00:09:27,920 --> 00:09:29,210
Entonces vamos a levantar.

181
00:09:30,360 --> 00:09:30,570
Vamos.

182
00:09:30,630 --> 00:09:31,200
Qué pasa?

183
00:09:34,960 --> 00:09:35,420
Veamos.

184
00:09:36,010 --> 00:09:39,280
Continuando con la ejecución del método Main ta perfecto.

185
00:09:39,450 --> 00:09:40,720
Esto acá entre el while.

186
00:09:41,290 --> 00:09:42,940
Por lo tanto, ejecutando la tarea.

187
00:09:43,060 --> 00:09:43,570
Lo primero.

188
00:09:43,660 --> 00:09:45,040
Después comienza la tarea.

189
00:09:46,040 --> 00:09:51,590
Porque acá queda en espera 1,5 segundos o 1500 milisegundos, después comienza la tarea.

190
00:09:51,680 --> 00:09:57,800
Inicio la tarea en nombre Drizzt llega quien espera por tres segundos simulando una tarea pesada.

191
00:09:58,520 --> 00:10:00,080
Después continúa con el.

192
00:10:01,010 --> 00:10:04,640
Se fijan como quedó entre segundo en espera acá.

193
00:10:04,640 --> 00:10:06,980
Acá empieza a esperar a que termine la tarea.

194
00:10:07,190 --> 00:10:10,790
Entonces acá 1,5 segundos imprime ejecutando tarea.

195
00:10:11,030 --> 00:10:13,520
Lo imprime dos veces y después finaliza la tarea.

196
00:10:14,580 --> 00:10:21,780
Nul itro perfecto, ahí finalizó con truo finaliza la tarea vamos a colocar acá

197
00:10:24,660 --> 00:10:25,080
la tarea.

198
00:10:27,420 --> 00:10:29,400
Acá sería resultado.

199
00:10:37,180 --> 00:10:37,920
Trataré algo.

200
00:10:39,950 --> 00:10:41,960
Pero estamos utilizando un Nabeel.

201
00:10:42,170 --> 00:10:45,320
Ahora vamos a trabajar con cable y vemos la diferencia.

202
00:10:46,190 --> 00:10:51,590
Entonces el Summit, cuando empezamos una ejecución, acepta un rabel o un calaban.

203
00:10:52,690 --> 00:10:53,410
Vamos a cambiar.

204
00:10:53,620 --> 00:10:56,370
Vamos a modificar Renauld por cállate.

205
00:10:57,130 --> 00:11:01,330
Entonces cantable acá maneja un tipo genérico.

206
00:11:01,420 --> 00:11:07,840
El tipo de dato que va a devolver puede ser cualquier tipo, un objeto, cliente, usuario, factura,

207
00:11:07,900 --> 00:11:08,560
lo que queramos.

208
00:11:09,610 --> 00:11:11,040
Pero también podría ser un string.

209
00:11:12,390 --> 00:11:13,730
Lleca tiene que devolver un valor.

210
00:11:14,120 --> 00:11:22,070
Entonces después, cuando finaliza el método este de acá, Croton devuelve este objeto lo que queramos.

211
00:11:22,160 --> 00:11:23,930
Puede ser un resultado de una consulta,

212
00:11:30,260 --> 00:11:31,280
algún resultado importante?

213
00:11:31,280 --> 00:11:31,730
La tarea?

214
00:11:33,050 --> 00:11:33,590
Perfecto.

215
00:11:33,710 --> 00:11:40,220
Y este resultado que devuelve el clavel, finalmente lo trema a través del resultado con el objeto.

216
00:11:40,540 --> 00:11:42,420
Acá vienen con el nyet.

217
00:11:43,160 --> 00:11:46,010
Entonces ahora en futur en en colocar el signo.

218
00:11:46,010 --> 00:11:48,830
Pregunta ya no el nulo es del tipo string.

219
00:11:49,580 --> 00:11:51,890
Ya qué es lo que está devolviendo la tarea?

220
00:11:52,460 --> 00:11:55,070
Acá lo que se imprime en el gueto es del tipo String.

221
00:11:55,190 --> 00:11:59,970
Ahora voy a quitar esto porque ya no nos estamos ocupando de esto solamente para el time out.

222
00:12:03,400 --> 00:12:07,030
Con la cara acá dos punto, un espacio y vamos a ejecutar.

223
00:12:15,150 --> 00:12:18,300
Obtenemos resultado la tarea, algún resultado importante, la tarea.

224
00:12:18,840 --> 00:12:22,980
Este es el resultado futuro que devuelve la tarea que está en ejecución.

225
00:12:23,040 --> 00:12:26,730
Esta tarea asíncrona y concurrente bien está molesto.

226
00:12:26,880 --> 00:12:33,150
Entonces, para ir cerrando este tema, recuerden que el Calafell devuelve un valor a diferencia del

227
00:12:33,240 --> 00:12:35,370
rentable, quien no devuelve nada.

228
00:12:35,640 --> 00:12:43,080
La única diferencia, pero ambas son tareas y ambas la podemos ejecutar o enviar a ejecución en el ejecutor.

229
00:12:43,140 --> 00:12:48,930
En el ejecutor con el submit acepta estos dos tipo obtenemos un valor o representación futura de la

230
00:12:48,930 --> 00:12:55,590
tarea y a través de este futuro o resultado futuro lo podemos manejar, lo podemos manipular, saber

231
00:12:55,590 --> 00:13:01,260
si ha terminado, iterar, bloquear el dret principal, invocar el resultado.

232
00:13:01,260 --> 00:13:03,300
Si invocamos el resultado, también se bloquea.

233
00:13:03,660 --> 00:13:03,960
En fin.

234
00:13:04,050 --> 00:13:06,540
Y también podemos cancelar la tarea en cualquier momento.

235
00:13:06,750 --> 00:13:07,290
Nada más.

236
00:13:07,320 --> 00:13:09,250
Continuamos en la siguiente clase.