1
00:00:00,240 --> 00:00:05,880
Bien, veamos un ejemplo cuando se repiten las tareas, vamos a cerrar y copiamos, copiamos este mismo

2
00:00:06,540 --> 00:00:12,900
y lo pegamos acá, lo modificamos, por ejemplo, vamos a colocar período, es decir, se repite cada

3
00:00:12,900 --> 00:00:14,730
cierto período de tiempo, ok.

4
00:00:15,420 --> 00:00:18,390
También es la misma idea filosofìa que el timer.

5
00:00:18,480 --> 00:00:19,200
Y en qué cambia?

6
00:00:19,380 --> 00:00:20,490
Bueno, en el método.

7
00:00:20,580 --> 00:00:22,980
En vez de implementar el es queda Helge.

8
00:00:23,190 --> 00:00:24,990
De hecho lo vamos a quitar.

9
00:00:27,080 --> 00:00:32,730
O más que quitar, lo vamos autocompletar, porque acá tenemos el sketch at fix right.

10
00:00:33,050 --> 00:00:34,990
Y también tenemos con fix delay.

11
00:00:35,240 --> 00:00:36,650
Cuál es la diferencia entre uno y otro?

12
00:00:36,830 --> 00:00:42,830
Bueno, en realidad son muy parecidos, pero tiene una semántica distinta y funciona al día, por supuesto.

13
00:00:42,950 --> 00:00:50,150
Bueno, el primero, el fix raid es de una tasa fija, es decir, es el tiempo en que se demora ejecutar

14
00:00:50,180 --> 00:00:51,940
cada tarea, el periodo tiempo.

15
00:00:52,130 --> 00:00:55,010
Entonces entre que se ejecuta una y se ejecuta la otra.

16
00:00:55,130 --> 00:00:56,690
Vamos a tener un intervalo tiempo.

17
00:00:56,780 --> 00:01:03,110
Ahora, por supuesto, si una tarea se demora más de la cuenta, más de ese tiempo se acopla un poco,

18
00:01:03,230 --> 00:01:08,660
se ajusta, es flexible y cuando finaliza su tarea, que se demoró más de este tiempo, automáticamente

19
00:01:08,660 --> 00:01:16,250
comienza la siguiente tarea, mientras que la otra con fix delay es con un delay fijo entre la tarea.

20
00:01:16,460 --> 00:01:20,840
Es decir, es similar a la anterior porque se ejecuta de forma repetida una tarea.

21
00:01:20,930 --> 00:01:26,750
Pero este retraso de ley se mide desde el final de una tarea y el comienzo de la siguiente tarea.

22
00:01:26,870 --> 00:01:30,050
Por lo tanto, es independiente al tiempo de ejecución de tarea.

23
00:01:30,200 --> 00:01:35,150
Eso da lo mismo siempre assistir un delay entre que termina una tarea y comienza la siguiente.

24
00:01:35,330 --> 00:01:36,080
Esa es la diferencia.

25
00:01:36,170 --> 00:01:38,120
Bien, para el ejemplo podría utilizar cualquiera.

26
00:01:38,270 --> 00:01:47,150
Vamos a utilizar esta acá, pero también una tarea a ejecutarse que se repite un tiempo de ley de comienzo,

27
00:01:47,160 --> 00:01:48,470
de inicio podría ser cero.

28
00:01:48,500 --> 00:01:54,860
Comienza inmediatamente, pero faltaría el tiempo o período en que se ha repetido cada cuánto tiempo.

29
00:01:55,040 --> 00:02:00,080
Por ejemplo, podríamos colocar cada dos mil milisegundos, dos segundos.

30
00:02:00,170 --> 00:02:07,220
Y acá que comience con un delay de un segundo, es decir, un retraso de un segundo y después cada segundo

31
00:02:07,340 --> 00:02:09,120
se va ejecutando, se va repitiendo.

32
00:02:09,230 --> 00:02:16,340
Pero recuerden estos dos segundos en el caso del AT Fix right significa que la tarea, es decir, cada

33
00:02:16,340 --> 00:02:18,110
tareas a ejecutar en dos segundos.

34
00:02:18,650 --> 00:02:21,080
Entonces levantamos.

35
00:02:21,440 --> 00:02:22,730
Bueno, no pasa nada.

36
00:02:22,880 --> 00:02:23,430
Por qué?

37
00:02:23,870 --> 00:02:26,900
Porque hace un chaddha, se apaga y es un tema.

38
00:02:26,990 --> 00:02:32,330
Entonces para poder ejecutar la tarea tiene que esperar durante algún tiempo para que se ejecute repetidas

39
00:02:32,330 --> 00:02:35,000
veces, ya sea con alguna bandera.

40
00:02:35,030 --> 00:02:41,270
Como vimos también en Timmer, que se ejecute tres veces o cuatro veces o durante un tiempo pasa dejar

41
00:02:41,270 --> 00:02:46,580
bloqueado el thread con una pausa, en fin, porque si no se apaga y termina la ejecución.

42
00:02:46,790 --> 00:02:49,100
Finalmente nos ejecuta la tarea y nos repite.

43
00:02:49,160 --> 00:02:55,340
Entonces vamos a ver distinto mecanismo para lograr que esto se ejecute, ya sea indefinidamente o bien

44
00:02:55,340 --> 00:03:00,530
durante un periodo tiempo determinado o bien durante una cantidad de veces determinada.

45
00:03:00,680 --> 00:03:03,740
Por ejemplo, si queremos que se ejecute durante un tiempo determinado.

46
00:03:03,830 --> 00:03:04,880
Bueno, muy simple.

47
00:03:05,120 --> 00:03:08,840
Con tan junquito punto.

48
00:03:08,900 --> 00:03:12,230
Por ejemplo segundos sleep.

49
00:03:12,980 --> 00:03:18,890
Entonces dejamos pasar esto para que se vaya ejecutando diez segundos y lanzamos esta acepción al método.

50
00:03:20,150 --> 00:03:20,840
Listo.

51
00:03:21,410 --> 00:03:21,950
Ahora sí que sí.

52
00:03:22,550 --> 00:03:23,570
Entonces ejecutamos.

53
00:03:27,440 --> 00:03:33,920
Hola Mono, tarea 1 2 se fijan durante un tiempo, durante 10 segundos, la cantidad de veces hasta

54
00:03:33,920 --> 00:03:36,440
que termine el sleep, porque después se apaga el Chandon.

55
00:03:37,890 --> 00:03:39,360
Entonces, alguna tarea de main?

56
00:03:40,610 --> 00:03:43,040
Se imprime esto, después ejecuta esta tarea.

57
00:03:43,460 --> 00:03:53,720
Dejamos bloqueado el driver principal y comienza 1 2 3 4 5 5 veces en los 10 segundos.

58
00:03:53,750 --> 00:03:57,400
Claro, porque en cada una hace una pausa de un segundo.

59
00:03:58,520 --> 00:04:00,290
Y después ejecuta alguna otra tarea.

60
00:04:00,950 --> 00:04:04,400
Otra alternativa bueno es quitar esto y quitar el chato.

61
00:04:04,460 --> 00:04:06,200
Pero queda hasta el infinito.

62
00:04:06,320 --> 00:04:07,370
Se empieza a ejecutar.

63
00:04:09,130 --> 00:04:12,010
Una y otra vez, hasta que detengamos acá, se fijan.

64
00:04:12,790 --> 00:04:15,560
Pero eso puede ser indeterminadas veces.

65
00:04:19,860 --> 00:04:20,870
Bien, suficiente.

66
00:04:21,030 --> 00:04:26,030
Voy a detener entonces por eso importante el chato apagar el executar.

67
00:04:27,700 --> 00:04:32,770
Una forma seria con este Lieb durante un tiempo, pero también podría ser durante una cantidad de veces

68
00:04:32,920 --> 00:04:34,840
y para eso tenemos diferentes técnica.

69
00:04:34,960 --> 00:04:35,770
Vamos a ver alguna.

70
00:04:35,890 --> 00:04:36,760
Esto lo de comentar.

71
00:04:38,290 --> 00:04:42,880
Bien, acabo de crear una instancia de una cuenta regresiva, es decir, repartir.

72
00:04:42,910 --> 00:04:47,350
Por ejemplo, en 5 y se va a ejecutar 5S hasta llegar a cero.

73
00:04:47,440 --> 00:04:52,450
Similar a lo que vimos también en el ejemplo anterior con Timber, pero utilizando la implementación

74
00:04:52,540 --> 00:04:57,340
count down latch count down lacho.

75
00:04:58,920 --> 00:05:05,580
LOC o bloqueador en el fondo te bloquea también Eldred hasta que finalice la cuenta regresiva.

76
00:05:06,030 --> 00:05:09,860
Acá creamos una instancia con el operador New 5.

77
00:05:10,110 --> 00:05:17,490
Entonces Veidt de 5 hasta llegar a cero y cuando llega a cero termina esta clase también en el package

78
00:05:17,580 --> 00:05:18,140
concurrente.

79
00:05:18,240 --> 00:05:23,070
Por lo tanto, puede operar de forma concurrente, de forma atómica, muy similar a lo que hicimos con

80
00:05:23,070 --> 00:05:24,030
el Atomic Quintilla.

81
00:05:24,120 --> 00:05:28,620
De hecho, vamos a ver este mismo ejemplo con Atomic Quintilla también es similar, pero la forma implementar

82
00:05:28,620 --> 00:05:29,430
un poco distinta.

83
00:05:30,270 --> 00:05:37,080
Entonces en cada llamada a la tarea tenemos que descontar o decremento dar esta cuenta regresiva.

84
00:05:37,230 --> 00:05:46,680
Entonces por acá utilizamos el lock count down va descontando qoie que se ejecuta la tarea y después

85
00:05:46,680 --> 00:05:52,360
por acá en vez de utilizar el sleep usamos el log y bloqueamos el Drizzt.

86
00:05:52,470 --> 00:05:59,280
Esperamos con wait ya sea a secas lo loqui hasta que llegue a cero o bien con un time out.

87
00:05:59,400 --> 00:06:01,710
Acá espera a que se cumpla el time out.

88
00:06:01,830 --> 00:06:07,200
Si se muere más de la cuenta continúa con la ejecución, es decir, de bloqueà el main o el try, o

89
00:06:07,200 --> 00:06:12,360
bien si llega a cero lo que ocurra, primero vamos a utilizar esta de acá que llegue a cero nomás.

90
00:06:12,480 --> 00:06:15,180
Es decir, que se ejecute cinco veces hasta llegar a cero.

91
00:06:15,960 --> 00:06:18,210
Entonces con el wait bloqueamos el try.

92
00:06:18,480 --> 00:06:19,530
Quedamos en espera.

93
00:06:20,250 --> 00:06:20,970
Veamos cómo sería.

94
00:06:21,130 --> 00:06:22,620
Entonces ejecutamos.

95
00:06:25,070 --> 00:06:25,790
Hola Mundo!

96
00:06:25,850 --> 00:06:27,480
Una, dos.

97
00:06:28,750 --> 00:06:29,340
3.

98
00:06:30,770 --> 00:06:31,450
4.

99
00:06:32,660 --> 00:06:33,280
5.

100
00:06:33,850 --> 00:06:35,500
Finaliza alguna trataria M?

101
00:06:36,440 --> 00:06:38,450
Y también podríamos cancelar la tarea.

102
00:06:38,850 --> 00:06:44,210
Bueno, igualmente cuando hacemos un chat down se va cancelar y se apaga todo, pero de una forma un

103
00:06:44,210 --> 00:06:49,520
poco más educada, podríamos cancelar esta tarea antes de apagar el ejecutor.

104
00:06:50,240 --> 00:06:53,060
Entonces recuerden que acá podemos obtener el futuro.

105
00:06:55,050 --> 00:06:59,840
Tiene pregunta Phew, Chord Future o el nombre que queramos.

106
00:06:59,930 --> 00:07:00,890
Importamos?

107
00:07:01,190 --> 00:07:01,960
Perfecto.

108
00:07:02,220 --> 00:07:03,800
Y acá tenemos este objeto.

109
00:07:04,100 --> 00:07:07,220
Lo podemos cancelar entonces, cuando termina esperar.

110
00:07:07,250 --> 00:07:14,150
Cuando llega a cero cancel true constru lo cancela de forma automática.

111
00:07:14,360 --> 00:07:18,530
Si colocamos fols va a cancelar, pero va a esperar que termine la tarea de ejecución.

112
00:07:20,080 --> 00:07:21,550
Bueno, en realidad resultó, no cambia.

113
00:07:25,950 --> 00:07:26,640
2.

114
00:07:27,180 --> 00:07:27,750
3.

115
00:07:29,170 --> 00:07:29,840
4.

116
00:07:31,130 --> 00:07:37,280
5 Y finaliza bien, veamos otra forma, vamos a comentar esto.

117
00:07:37,670 --> 00:07:48,110
El LOC acá comentamos este de acá y comentamos el Contour Lat y lo vamos a cambiar por un Atomic Intellectus

118
00:07:52,100 --> 00:07:58,400
Contador igual New Atomic Integer también de 5.

119
00:07:59,960 --> 00:08:03,080
Bien, también se importa de lleba útil concurrente.

120
00:08:04,300 --> 00:08:13,120
En vez de utilizar acá el Countdown del Latch, utilizamos el contador Punto Guet ante Cremento.

121
00:08:14,130 --> 00:08:20,850
Incrementamos cada que se ejecuta una tarea bien y acá afuera vamos a comentar acá el future cancel,

122
00:08:21,840 --> 00:08:26,610
acá a diferencia tenemos que hacer o detener o bloquear este hilo con un while.

123
00:08:26,910 --> 00:08:28,080
Entonces con un while.

124
00:08:28,620 --> 00:08:32,010
Entonces, mientra el valor de este contador contador.

125
00:08:32,400 --> 00:08:33,220
Punto get.

126
00:08:34,110 --> 00:08:36,060
Recuerden que el contador punto nyet.

127
00:08:36,150 --> 00:08:42,210
Lo que retorna es un tipo integer entero con el valor entonces sea mayor o igual a cero.

128
00:08:42,570 --> 00:08:45,600
Nos mantenemos en el grupo y tirando con un while.

129
00:08:45,750 --> 00:08:48,420
Entonces va a iterar hasta que sea cero.

130
00:08:48,840 --> 00:08:51,900
Y acá con un if ya cuando es igual a cero.

131
00:08:52,140 --> 00:08:56,760
Entonces Contador pun to get igual a cero.

132
00:08:56,940 --> 00:08:59,400
Similar a la cuenta regresiva que vimos anteriormente.

133
00:08:59,640 --> 00:09:00,270
Cancelamos.

134
00:09:00,360 --> 00:09:02,430
Colocamos Deutscher Punto Cancel.

135
00:09:05,160 --> 00:09:11,610
Trou Y tenemos que volver a decretar, incrementamos para que acá detenemos la tarea.

136
00:09:11,670 --> 00:09:17,400
Entonces tenemos que decretar para que vuelva al UIL a iterar y sea menor que cero, es decir, de cero

137
00:09:17,400 --> 00:09:19,410
pasa a menos uno y se sale iguai.

138
00:09:19,590 --> 00:09:21,540
Por lo tanto, libera este bloqueo.

139
00:09:21,750 --> 00:09:23,700
Entonces, contador.

140
00:09:23,850 --> 00:09:24,540
Punto.

141
00:09:24,870 --> 00:09:26,040
Get an decremento.

142
00:09:27,790 --> 00:09:31,170
Aunque también podríamos hacer un break para salirnos del wine.

143
00:09:31,300 --> 00:09:35,530
También sería otra forma con un break y nos salimos de guay sin decremento.

144
00:09:36,190 --> 00:09:38,260
Bueno, pero al final es lo mismo.

145
00:09:38,530 --> 00:09:38,980
Listo.

146
00:09:39,070 --> 00:09:43,120
Ahí tenemos utilizando Atomic Integer va incrementando.

147
00:09:43,150 --> 00:09:48,160
Pero también tenemos acá un while para bloquear y monitorear cuando llegue a cero.

148
00:09:48,280 --> 00:09:50,390
Cancelamos la tarea decremento.

149
00:09:50,400 --> 00:09:50,770
Vámonos.

150
00:09:50,770 --> 00:09:54,430
Olimos de Wahl y continuamos con la ejecución y apagamos el ejecutor.

151
00:09:56,010 --> 00:09:58,980
Entonces, como resultado, el mismo ejecuta la tarea cinco veces.

152
00:10:07,430 --> 00:10:10,290
Se fijan y se sale alguna altanería en M.

153
00:10:10,700 --> 00:10:11,120
Y eso?

154
00:10:11,210 --> 00:10:15,320
Tarea programada utilizando el Freinet gor executar servis.

155
00:10:15,620 --> 00:10:16,310
Nada más.

156
00:10:16,430 --> 00:10:18,500
Continuamos en la siguiente clase.