Continuamos.
Cuando enviamos una tarea a ejecución con el submit.
Bueno, lo que podría devolver es un objeto del tipo feúcha.
O futuro, que es una representación de esta tarea que se está ejecutando.
Y podemos realizar un rastreo, una trazabilidad de esta tarea que está en ejecución.
Por ejemplo, la podemos cancelar.
Podemos saber si ha finalizado o si está en ejecución o si ha sido cancelada.
En fin, un montón de cosas.
Y también podría devolver un valor, retornar un resultado final.
Esta tarea también la podríamos obtener con este objeto futuro.
Recuerden, entonces representa un resultado futuro de esta operación asíncrona.
Dependiendo si es rentable la tarea o cable podría devolver un resultado y este resultado podría aparecer.
Pero después, una vez que se procese y se termine la tarea en el futuro, entonces por eso es el tipo
de dato futuro.
Veamos el ejemplo para no modificar esto que tenemos.
Voy a cerrar y voy a copiar.
Ejemplo executar.
Lo pegamos y vamos a colocar acá.
Fouché.
Ok, bien, vamos a quitar esto.
Lo eliminamos.
Dejamos solamente continuando con la operación del método Main.
Vamos a trabajar con el futuro, pero esto es geto.
Lo tenemos a través del zumbido.
El submit devuélvete sugeto una representación futura de la tarea.
Entonces futura of voucher maneja también tipo de auto genérico.
Como es del tipo razonable, la tarea no devuelve nada.
Por lo tanto, vamos a colocarnos.
Si no pregunta acá me comí el ejecutor y acá en nombre de le vamos a colocar un resultado resultado
un resultado futuro de la tarea bien y filter se importa.
Recuerden de lleba útil concurrente.
Bien y acá vamos a imprimir shout resultado futuro en realidad.
Punto.
Acá tenemos el método I'S donde se ha terminado.
También tenemos si ha sido cancelado, podemos cancelar esta tarea.
Y con qué podemos obtener el valor futuro o el resultado futuro que eventualmente podría retornar?
La tarea dependiendo cierra nivel no retorna nada, pero si es escalable va a retornar un valor.
Bien, vamos a colocar Down.
Si ha finalizado.
Pero por supuesto que no!
Por qué?
Recuerden que tienen un delay de 5 segundos.
Voy a cambiar a 3 para que no sea tanto.
Entonces qué a.
Voy a ejecutar lo primero que se imprime.
Continuando con la ejecución del método Main, después imprime is down falso y comienza la tarea porque
tiene ese pequeño delay.
Entonces va a mostrar inicio la tarea y todo lo demás.
Nombre del Dredd.
Y después finaliza la tarea.
Vamos a probar.
Se fijan, continuando con la ejecución de me tomé fols.
Por lo tanto no ha finalizado, ya que está recién comenzando la tarea con este delay de 3 segundos.
Bien, pero también podría obtener este valor futuro independientes en Nul.
En el caso del ranees, recuerden que null.
Por lo tanto, si imprimo acá el shout resultado, punto, nyet, va a retornar un null.
Acá me pide manejar el trait catch dos excepciones Interruptor Deception y también execute en Exception
estas dos excepciones.
Entonces puedes se contradic catch o se declaran en el método vamos a colocar declarar en el método.
Acá tenemos las dos intercepte y execucion excepto.
Bien.
Pero qué hace el Quiete?
El nyet, hay que tener cuidado.
No siempre es bueno llamarlo porque bloquea el dirig actual.
Quien espera hasta que se ejecute la tarea, finalice y devuelva el valor.
Claro, por poner un ejemplo, para que lo vean visualmente.
Voy a imprimir otra cosa.
Shout continuamos.
Entonces, qué va a pasar?
Bueno, voy a imprimir.
Continuando con la ejecución del método Main.
Falso.
Acá invoca al Gillet.
Por lo tanto obtiene el resultado.
Pero como no devuelve nada, va a imprimir null.
Y acá se bloquea.
Acá se da bloquear durante tres segundos hasta que finaliza la tarea.
Y después de imprimir todo inicio de tarea en nombre del Dredd.
Finaliza la tarea después de finalizar la tarea.
Imprime.
Continuamos.
Por qué queda bloqueado el método Main con el nyet?
Lo bloquea.
Por así decir.
Syria como similar.
Se acuerdan al método GEIN del Drizzt?
Que en el fondo el thread principal que está ejecutando otro Drizzt.
Espera a que finalice ese adrid.
Bueno, acá pasa algo similar.
Espere a que finalice y que devuelva el resultado.
Vamos a ver.
Entonces.
El último que retorna o que imprime consola.
Continuamos.
Se fijan en la tarea?
Finaliza la tarea.
Nul porque no devuelve nada y continuamos.
Pero acá se da una pausa porque bloquea el drid o el método Main.
Ahora, qué pasa si colocamos esto acá?
Bueno sea imprimir esto primero.
Después fols.
Y después continuamos.
Y después comienza la tarea.
Pontifican continuamos continuando con la tarea fols continuamos y después comienza la tarea finaliza
y acá se bloquea, se bloquea hasta obtener el nul.
El resultado.
Bien, esto ya lo voy a quitar.
Хотя resultado.
Punto I.
II.
Ahora estás defaults y te a thru?
Claro, porque el gillet espera a que finalice y acá después del nyet va a haber finalizado.
Entonces fols con el jet?
Espera.
Bloquea el main hasta que finaliza la tarea.
Comienza.
Se ejecuta.
Finaliza.
Retorna el resultado.
Nul y Thru ha terminado.
Bien, el nyet también acepta un parámetro, un time out.
Acá se demora 3 segundos y puede colocar un auto.
Por ejemplo, no se puede demorar más de dos segundos en ejecutar la tarea.
Y si se demora más de dos segundos, bueno, que lance una acepción de time out.
Un error time y unit punto secondo.
Y acá nos pide manejar otra acepción.
Una tercera.
El timeout exceptúan puede lanzar esta excepción en caso de que se cumpla el tiempo de Time out.
Primero, antes que finalice la ejecución de la tarea.
Bueno, si esto lo ejecuto, por supuesto que queda lanzar un error solamente para que lo vean nada
más.
Se muere más del tiempo y lanza esta sección de Time out Time Out, excepto ahora.
Por supuesto, si lo colocamos, no sé.
5.
Hoy no hay problema porque se demoran menos en ejecutar la tarea y el tiempo espera en mayor.
Bueno, esto es útil cuando una tarea se pueden ver en mucho, mucho rato y queremos evitar un bloqueo
o que el usuario esté esperando que finalice un proceso.
Quién no debería de tomar mucho tiempo?
Entonces, si se demoran más de la cuenta?
Bueno, lanzar el error.
Bien, vamos a probar acá.
Debería funcionar bien, sin error.
Se fijan y finalizaban porque les dimos más tiempo al time out, qué más bien acabo de comentar esto.
Íbamos a ver otra forma con un quail, claro.
Podríamos ser un wile.
Es decir, mientras no haya finalizado con un distinto resultado.
Punto es donde.
Es decir, mientras no haya finalizado Shout.
Ejecutando tarea y acá podríamos hacer un loop para que nos imprima tantas veces ejecutando tareas.
Por qué está preguntando el Weill constantemente, varias veces hasta que haya finalizado el proceso.
Entonces, como se muera 3 segundos acá podríamos hacer un sleep, un time y unit 1 second punto sleep,
por ejemplo, de 1500 milisegundos, es decir, de la mitad.
Vamos a levantar.
Bueno, debería imprimir como 3 veces ejecutando tarea.
Por qué?
Bueno, primero va a imprimir.
Continuando con la ejecución del método Main, lo primero que se imprime, después entra al while y
entremedio empieza a ejecutar la tarea.
Pero es probable que lo primero que se imprima ejecutando tarea como hace una pausa, se imprime iniciando
la tarea o inicio de tarea en nombre del try.
Acaso una pausa de tres.
Después vuelve a iterar después de 1500.
Perdón.
Acá es segundos.
Perdón.
Voy a colocar milisegundos.
Sí, porque no son 1500 segundos, sino 1,5 segundos.
Entonces voy a cambiar a milisegundos.
En este caso, para que sea más preciso milisegundos que sería 1,5 segundos.
A ese entonces va a estar imprimiendo esto entremedio de que se está ejecutando la tarea.
Y después, cuando finaliza, se sale del huai.
Por lo tanto, acá se queda bloqueado.
Es importante.
Acá queda bloqueado con el sleep hasta que finaliza.
Y cuando finaliza se sale del cual ya terminó y continúa con el quieto.
Por lo tanto, imprime el quiete.
Esto ya no sería necesario porque lo obtiene de forma automática e inmediata, ya que va a imprimir
true.
Por supuesto, porque ya finalizó.
Entonces vamos a levantar.
Vamos.
Qué pasa?
Veamos.
Continuando con la ejecución del método Main ta perfecto.
Esto acá entre el while.
Por lo tanto, ejecutando la tarea.
Lo primero.
Después comienza la tarea.
Porque acá queda en espera 1,5 segundos o 1500 milisegundos, después comienza la tarea.
Inicio la tarea en nombre Drizzt llega quien espera por tres segundos simulando una tarea pesada.
Después continúa con el.
Se fijan como quedó entre segundo en espera acá.
Acá empieza a esperar a que termine la tarea.
Entonces acá 1,5 segundos imprime ejecutando tarea.
Lo imprime dos veces y después finaliza la tarea.
Nul itro perfecto, ahí finalizó con truo finaliza la tarea vamos a colocar acá
la tarea.
Acá sería resultado.
Trataré algo.
Pero estamos utilizando un Nabeel.
Ahora vamos a trabajar con cable y vemos la diferencia.
Entonces el Summit, cuando empezamos una ejecución, acepta un rabel o un calaban.
Vamos a cambiar.
Vamos a modificar Renauld por cállate.
Entonces cantable acá maneja un tipo genérico.
El tipo de dato que va a devolver puede ser cualquier tipo, un objeto, cliente, usuario, factura,
lo que queramos.
Pero también podría ser un string.
Lleca tiene que devolver un valor.
Entonces después, cuando finaliza el método este de acá, Croton devuelve este objeto lo que queramos.
Puede ser un resultado de una consulta,
algún resultado importante?
La tarea?
Perfecto.
Y este resultado que devuelve el clavel, finalmente lo trema a través del resultado con el objeto.
Acá vienen con el nyet.
Entonces ahora en futur en en colocar el signo.
Pregunta ya no el nulo es del tipo string.
Ya qué es lo que está devolviendo la tarea?
Acá lo que se imprime en el gueto es del tipo String.
Ahora voy a quitar esto porque ya no nos estamos ocupando de esto solamente para el time out.
Con la cara acá dos punto, un espacio y vamos a ejecutar.
Obtenemos resultado la tarea, algún resultado importante, la tarea.
Este es el resultado futuro que devuelve la tarea que está en ejecución.
Esta tarea asíncrona y concurrente bien está molesto.
Entonces, para ir cerrando este tema, recuerden que el Calafell devuelve un valor a diferencia del
rentable, quien no devuelve nada.
La única diferencia, pero ambas son tareas y ambas la podemos ejecutar o enviar a ejecución en el ejecutor.
En el ejecutor con el submit acepta estos dos tipo obtenemos un valor o representación futura de la
tarea y a través de este futuro o resultado futuro lo podemos manejar, lo podemos manipular, saber
si ha terminado, iterar, bloquear el dret principal, invocar el resultado.
Si invocamos el resultado, también se bloquea.
En fin.
Y también podemos cancelar la tarea en cualquier momento.
Nada más.
Continuamos en la siguiente clase.