1
00:00:00,050 --> 00:00:37,990
Vale, venga, pues a ver, ejercicio 2, venga, pues el 2, a ver si está por aquí todavía, venga, pues nada, de este nos olvidamos dos clases, un gestor de tareas, un gestor de procesos y los procesos tienen tres propiedades, vale,

2
00:00:37,990 --> 00:00:45,369
Y luego un planificador que hace cosas con esos procesos que los tiene guardados en dos colecciones dentro.

3
00:00:46,070 --> 00:00:47,810
Entonces, lo primero, pues hacemos el proceso.

4
00:00:47,810 --> 00:01:05,030
Vale, el proceso tiene su identificador de proceso, que tiene que ser entero.

5
00:01:06,290 --> 00:01:10,930
Su identificador de proceso, prioridad y duración.

6
00:01:11,349 --> 00:01:12,150
Todos enteros.

7
00:01:15,859 --> 00:01:17,040
Pues, hala, todos aquí.

8
00:01:17,040 --> 00:01:19,159
prioridad, aquí no había

9
00:01:19,159 --> 00:01:21,060
nada de herencia ni de nada, esto era solo

10
00:01:21,060 --> 00:01:22,719
para colecciones, ya está

11
00:01:22,719 --> 00:01:26,950
entonces, les ponemos

12
00:01:26,950 --> 00:01:28,230
un getter y setter

13
00:01:28,230 --> 00:01:38,219
y ahora el constructor

14
00:01:38,219 --> 00:01:40,939
el constructor nos lleva rápidamente a la idea

15
00:01:40,939 --> 00:01:42,760
de qué pasa cuando este

16
00:01:42,760 --> 00:01:44,959
proceso se genere, el constructor

17
00:01:44,959 --> 00:01:46,560
ya sabemos qué es lo que se invoca

18
00:01:46,560 --> 00:01:48,519
cuando el objeto se crea

19
00:01:48,519 --> 00:01:50,760
vale, pues en ese momento

20
00:01:50,760 --> 00:01:52,939
de crear el objeto, nos han dado alguna información

21
00:01:52,939 --> 00:01:53,719
a tener en cuenta

22
00:01:53,719 --> 00:01:57,180
pues sí, nos han dicho

23
00:01:57,180 --> 00:01:59,000
que la propiedad pit

24
00:01:59,000 --> 00:02:01,040
esta, el identificador del proceso

25
00:02:01,040 --> 00:02:02,920
se tiene que generar

26
00:02:02,920 --> 00:02:05,099
automáticamente cuando el proceso se crea

27
00:02:05,099 --> 00:02:06,959
es decir, no se da desde

28
00:02:06,959 --> 00:02:09,039
fuera, como la prioridad y la duración

29
00:02:09,039 --> 00:02:11,460
no se da, sino que se genera automáticamente

30
00:02:11,460 --> 00:02:12,379
por la aplicación

31
00:02:12,379 --> 00:02:14,159
eso nos lleva

32
00:02:14,159 --> 00:02:16,919
a decidir

33
00:02:16,919 --> 00:02:18,879
que nuestro constructor entonces

34
00:02:18,879 --> 00:02:20,740
tiene dos parámetros, nuestro constructor

35
00:02:20,740 --> 00:02:22,819
va a tener solo dos parámetros, este

36
00:02:22,819 --> 00:02:24,819
y este, porque el

37
00:02:24,819 --> 00:02:26,039
pit no se pasa desde fuera

38
00:02:26,039 --> 00:02:32,319
vale, pues este es nuestro constructor

39
00:02:32,319 --> 00:02:34,759
con estos

40
00:02:34,759 --> 00:02:36,680
dos parámetros, pero

41
00:02:36,680 --> 00:02:38,719
claro, el identificador de proceso

42
00:02:38,719 --> 00:02:40,340
que es lo que lo caracteriza de forma

43
00:02:40,340 --> 00:02:42,060
lo que lo identifica de forma única

44
00:02:42,060 --> 00:02:44,020
pues tiene que generarse

45
00:02:44,020 --> 00:02:46,419
entonces, ¿cuál? ¿el que nos dé la gana a nosotros?

46
00:02:48,259 --> 00:02:48,699
no

47
00:02:48,699 --> 00:02:50,960
a ver, no puedo poner yo de repente

48
00:02:50,960 --> 00:02:51,900
aquí uno random

49
00:02:51,900 --> 00:02:53,960
así

50
00:02:53,960 --> 00:02:58,919
diciendo, bueno, vale, pues este

51
00:02:58,919 --> 00:03:00,340
efectivamente es uno

52
00:03:00,340 --> 00:03:02,580
entero

53
00:03:02,580 --> 00:03:05,120
con esto no tengo la garantía

54
00:03:05,120 --> 00:03:07,039
de que vayan a ser únicos, no lo tengo

55
00:03:07,039 --> 00:03:09,080
porque se puede repetir la aleatoriedad

56
00:03:09,080 --> 00:03:11,060
entonces, tenemos

57
00:03:11,060 --> 00:03:13,080
que hacer alguna otra cosa, bueno, pues

58
00:03:13,080 --> 00:03:15,060
eso, solo hay una

59
00:03:15,060 --> 00:03:17,240
manera, que es tomar una

60
00:03:17,240 --> 00:03:18,919
semilla, un algo

61
00:03:18,919 --> 00:03:21,060
una variable, una variable

62
00:03:21,060 --> 00:03:22,780
que sea la generadora de pits

63
00:03:22,780 --> 00:03:23,699
que sea la generadora

64
00:03:23,699 --> 00:03:26,639
esa variable ¿dónde la colocamos?

65
00:03:27,159 --> 00:03:28,699
pues bueno, uno podría hacer una clase

66
00:03:28,699 --> 00:03:30,719
aparte para poner esa especie

67
00:03:30,719 --> 00:03:32,719
de variable, variable que

68
00:03:32,719 --> 00:03:34,780
tiene que ser una variable que conserve su valor

69
00:03:34,780 --> 00:03:36,520
global, pues tendrá que ser estática

70
00:03:36,520 --> 00:03:38,860
eso es lo que nos viene a la cabeza cuando pensamos en una variable

71
00:03:38,860 --> 00:03:40,759
que conserva ahí su valor, que es la que me da

72
00:03:40,759 --> 00:03:43,240
la información del siguiente

73
00:03:43,240 --> 00:03:44,240
PID a usar

74
00:03:44,240 --> 00:03:46,419
la puedo meter en una clase aparte

75
00:03:46,419 --> 00:03:48,740
pero bueno, como esa información, esa variable

76
00:03:48,740 --> 00:03:50,500
está relacionada exclusivamente

77
00:03:50,500 --> 00:03:52,819
con procesos, pues para qué

78
00:03:52,819 --> 00:03:54,819
voy a crear una clase aparte por esa, la coloco aquí.

79
00:03:55,759 --> 00:03:58,479
Vale, pues venga, la coloco aquí y ya está.

80
00:03:58,580 --> 00:04:05,770
Y me hago yo aquí mi variable estática, por ejemplo, esta.

81
00:04:10,180 --> 00:04:12,400
Inicialmente, cero.

82
00:04:14,219 --> 00:04:17,339
A ver, siguiente, pit, quería yo poner.

83
00:04:22,199 --> 00:04:26,000
Vale, como solo la voy a usar, solo la voy a usar desde esta clase,

84
00:04:26,160 --> 00:04:28,839
solo la voy a usar aquí, la puedo poner como privada,

85
00:04:28,939 --> 00:04:29,800
pero solo la voy a usar aquí.

86
00:04:29,800 --> 00:04:32,920
Y ahora esta variable global que está aquí alojada

87
00:04:32,920 --> 00:04:35,500
Porque todas las variables tienen que estar alojadas en una clase

88
00:04:35,500 --> 00:04:37,740
Pues esta que está aquí alojada

89
00:04:37,740 --> 00:04:42,300
La uso yo de esta manera, por ejemplo

90
00:04:42,300 --> 00:04:44,720
Y ya está

91
00:04:44,720 --> 00:04:47,199
Entonces cada proceso que se construya

92
00:04:47,199 --> 00:04:50,420
Tiene un identificador distinto

93
00:04:50,420 --> 00:04:52,759
Y ese generador de identificadores

94
00:04:52,759 --> 00:04:57,779
Ese generador de identificadores

95
00:04:57,779 --> 00:05:00,199
Pues lo alojo aquí en esta variable estática y ya está

96
00:05:00,199 --> 00:05:02,100
¿Vale? Por ejemplo aquí

97
00:05:02,100 --> 00:05:07,490
Entonces la primera vez

98
00:05:07,490 --> 00:05:10,329
Que se cree un proceso

99
00:05:10,329 --> 00:05:12,089
La primera vez que se cree

100
00:05:12,089 --> 00:05:13,490
Para el primer proceso

101
00:05:13,490 --> 00:05:15,550
Es cuando se crea esta variable estática

102
00:05:15,550 --> 00:05:17,050
La primera vez

103
00:05:17,050 --> 00:05:18,870
Que se creará con cero

104
00:05:18,870 --> 00:05:20,050
¿Vale?

105
00:05:20,769 --> 00:05:23,110
Con lo cual el primer proceso se le pone un cero

106
00:05:23,110 --> 00:05:25,629
Y esa variable estática ya se queda ahí

107
00:05:25,629 --> 00:05:28,410
Y cuando se crea un siguiente proceso

108
00:05:28,410 --> 00:05:30,470
No se vuelve a crear esta variable

109
00:05:30,470 --> 00:05:32,470
Porque esa ya era una variable estática

110
00:05:32,470 --> 00:05:34,569
con lo cual ya estaba creada

111
00:05:34,569 --> 00:05:36,110
para el otro y es común para todos

112
00:05:36,110 --> 00:05:38,430
entonces esa no se vuelve a crear con 0 otra vez

113
00:05:38,430 --> 00:05:40,230
¿vale? no se vuelve a crear con 0

114
00:05:40,230 --> 00:05:42,250
entonces

115
00:05:42,250 --> 00:05:44,490
el siguiente proceso que se cree

116
00:05:44,490 --> 00:05:46,629
accederá a esta variable

117
00:05:46,629 --> 00:05:48,810
que tendrá un 1 porque se quedó incrementada

118
00:05:48,810 --> 00:05:49,389
del anterior

119
00:05:49,389 --> 00:05:52,430
¿vale? y el siguiente proceso que se cree

120
00:05:52,430 --> 00:05:54,790
pues tendrá, accederá a esta variable

121
00:05:54,790 --> 00:05:56,149
que no se ha creado de nuevas

122
00:05:56,149 --> 00:05:58,230
se creará de nuevas si no tuviera el static

123
00:05:58,230 --> 00:06:00,810
pero es que tiene el static

124
00:06:00,810 --> 00:06:02,389
luego no se ha creado de nuevas, se crea

125
00:06:02,389 --> 00:06:03,810
cuando se crea el primer objeto

126
00:06:03,810 --> 00:06:05,209
y ahí ya se queda para siempre

127
00:06:05,209 --> 00:06:08,230
porque es común para todos, no se vuelve a crear cada vez

128
00:06:08,230 --> 00:06:10,670
¿vale? eso era una variable estática

129
00:06:10,670 --> 00:06:14,209
bueno, pues vuestra es la manera más cómoda

130
00:06:14,209 --> 00:06:16,189
vale, pues entonces

131
00:06:16,189 --> 00:06:18,810
¿el proceso tiene algo más?

132
00:06:18,889 --> 00:06:19,129
nada

133
00:06:19,129 --> 00:06:21,329
tenemos un constructor

134
00:06:21,329 --> 00:06:24,410
que garantiza esta condición que nos han dicho

135
00:06:24,410 --> 00:06:25,910
garantiza esta, vale

136
00:06:25,910 --> 00:06:28,069
ahora, ¿qué más nos dicen?

137
00:06:28,430 --> 00:06:29,689
los procesos tienen un orden

138
00:06:29,689 --> 00:06:31,370
tienen un orden

139
00:06:31,370 --> 00:06:33,610
Ah bueno, pues si los procesos implementan un orden

140
00:06:33,610 --> 00:06:34,910
Implementar un orden

141
00:06:34,910 --> 00:06:37,490
Ya nos sale, pues vamos a implementar comparable

142
00:06:37,490 --> 00:06:39,290
Los procesos implementan este orden

143
00:06:39,290 --> 00:06:41,290
Vale, y ese orden cuál va a ser

144
00:06:41,290 --> 00:06:43,569
Por prioridad, pero si la prioridad es igual

145
00:06:43,569 --> 00:06:44,250
Por duración

146
00:06:44,250 --> 00:06:47,470
Asumimos entonces que no hay dos procesos

147
00:06:47,470 --> 00:06:48,810
De misma prioridad y misma duración

148
00:06:48,810 --> 00:06:51,410
Y si lo hay, pues son

149
00:06:51,410 --> 00:06:53,829
El mismo

150
00:06:53,829 --> 00:06:54,389
Venga

151
00:06:54,389 --> 00:06:57,050
Está en la misma posición, perdón

152
00:06:57,050 --> 00:06:59,709
Vale, pues entonces, al implementar un orden

153
00:06:59,709 --> 00:07:04,870
Pues vamos a hacer que implemente el comparable

154
00:07:04,870 --> 00:07:13,910
Para poder ser comparado con otro proceso

155
00:07:13,910 --> 00:07:17,430
Para poder ser comparado con otro proceso

156
00:07:17,430 --> 00:07:21,750
¿Cuál es la diferencia entre comparable y comparado?

157
00:07:23,009 --> 00:07:24,990
200.000 veces lo tengo que explicar

158
00:07:24,990 --> 00:07:30,579
Bueno, ahora como en este también hay que hacer un comparator

159
00:07:30,579 --> 00:07:31,480
Ahora lo hacemos

160
00:07:31,480 --> 00:07:32,519
¿Vale?

161
00:07:32,519 --> 00:07:41,000
Entonces, comparable es una capacidad que tiene una entidad, que es la capacidad de ser comparado con otro.

162
00:07:41,480 --> 00:07:43,120
Entonces, ¿quiénes implementan comparable?

163
00:07:43,560 --> 00:07:50,300
Las entidades de mi aplicación, las mesas, pueden ser comparables o no, porque pueden ser comparadas en orden con otras mesas.

164
00:07:50,899 --> 00:07:57,459
Los alumnos, clase alumno puede implementar comparable o no, porque puedo ponerle yo en orden con otro alumno, ¿vale?

165
00:07:57,459 --> 00:08:22,139
Eso es comparable, comparable es la capacidad de que una entidad sea puesta en comparación, a ver si va antes o después con otra, entonces comparable, ¿quién lo implementa? Las entidades de mi aplicación, lo que yo manejo, los alumnos, las mesas, los procesos, las botellas, lo que yo maneje en mi aplicación, las facturas, eso es lo que implementa comparable, ¿vale?

166
00:08:22,139 --> 00:08:25,560
vale, bueno, pues vamos a implementar

167
00:08:25,560 --> 00:08:27,339
aquí, entonces, si implementamos

168
00:08:27,339 --> 00:08:29,139
comparable hay que decir, oye, vale

169
00:08:29,139 --> 00:08:31,560
pues, ¿qué hace

170
00:08:31,560 --> 00:08:33,519
que tú estés por delante o por

171
00:08:33,519 --> 00:08:35,120
detrás de otro? ¿qué es lo que hace?

172
00:08:35,759 --> 00:08:37,559
pues lo que lo diga el método compare tú

173
00:08:37,559 --> 00:08:41,340
el método compare tú es el que te dice

174
00:08:41,340 --> 00:08:43,200
si tú vas antes o después de otro

175
00:08:43,200 --> 00:08:45,500
¿cómo? pues aquí estamos

176
00:08:45,500 --> 00:08:46,940
comparando el objeto dis

177
00:08:46,940 --> 00:08:49,700
estamos comparando dis

178
00:08:49,700 --> 00:08:51,899
¿con quién lo estamos comparando?

179
00:08:52,139 --> 00:08:53,059
Con O

180
00:08:53,059 --> 00:08:55,580
Comparamos

181
00:08:55,580 --> 00:08:58,299
Dis

182
00:08:58,299 --> 00:09:00,279
Con O

183
00:09:00,279 --> 00:09:02,360
¿Vale? A ver cuál va antes

184
00:09:02,360 --> 00:09:04,019
Y cuál va después, con este

185
00:09:04,019 --> 00:09:05,820
Pues depende de la prioridad

186
00:09:05,820 --> 00:09:06,879
Si

187
00:09:06,879 --> 00:09:09,779
En orden

188
00:09:09,779 --> 00:09:12,200
¿Cuál era ascendente o descendente de prioridad?

189
00:09:12,360 --> 00:09:14,539
En orden, supongo que ascendente

190
00:09:14,539 --> 00:09:15,860
Pues entonces

191
00:09:15,860 --> 00:09:17,720
Comparamos Dis con O, entonces

192
00:09:17,720 --> 00:09:18,960
Si

193
00:09:18,960 --> 00:09:33,799
Si la prioridad es distinta, es decir, si this.prioridad es distinta de o.prioridad, pues entonces está claro.

194
00:09:35,100 --> 00:09:43,759
return o.prioridad menos this.prioridad.

195
00:09:43,759 --> 00:09:45,059
Vamos a verificar.

196
00:09:45,059 --> 00:09:56,720
Ahora, si el proceso dis que llama al compare tú tiene más prioridad que el parámetro, esto es negativo.

197
00:09:57,200 --> 00:10:00,799
Negativo significa que va antes, justo, va antes el de más prioridad.

198
00:10:02,200 --> 00:10:09,580
Vale, si el proceso que llama tiene menos prioridad que este, esta resta es positiva.

199
00:10:10,220 --> 00:10:12,379
Positiva significa ir después, justo.

200
00:10:12,379 --> 00:10:13,799
Si tiene menos, vas después.

201
00:10:13,799 --> 00:10:20,690
Vale, ¿y qué pasa si no es la misma?

202
00:10:21,590 --> 00:10:22,950
Perdón, que si no es distinta

203
00:10:22,950 --> 00:10:25,490
Si no es distinta, pues la duración

204
00:10:25,490 --> 00:10:30,429
El de menor duración primero

205
00:10:30,429 --> 00:10:32,870
Entonces el de menor duración primero será

206
00:10:32,870 --> 00:10:40,409
Dis.duración menos o.duración

207
00:10:40,409 --> 00:10:42,029
¿Verdad?

208
00:10:42,610 --> 00:10:46,450
Si este que lo llama tiene menos duración

209
00:10:46,450 --> 00:10:48,789
Esta resta es negativa

210
00:10:48,789 --> 00:10:49,789
Luego va primero

211
00:10:49,789 --> 00:10:51,750
Que eso es lo que significa devolver negativo

212
00:10:51,750 --> 00:10:54,049
Si este que lo llama

213
00:10:54,049 --> 00:10:55,409
Tiene más duración

214
00:10:55,409 --> 00:10:57,269
Esta resta es positiva

215
00:10:57,269 --> 00:10:58,590
Luego va después

216
00:10:58,590 --> 00:11:00,669
Que es lo que significa dar positivo

217
00:11:00,669 --> 00:11:02,690
Pues ya está

218
00:11:02,690 --> 00:11:04,909
Entonces mis procesos

219
00:11:04,909 --> 00:11:07,830
Implementan el rol

220
00:11:07,830 --> 00:11:10,549
El papel de ser comparables

221
00:11:10,549 --> 00:11:11,230
Con otros

222
00:11:11,230 --> 00:11:13,129
Y su criterio de comparación es este

223
00:11:13,129 --> 00:11:17,990
Vale, seguimos

224
00:11:17,990 --> 00:11:21,830
Ya está, en proceso no hay más que hacer

225
00:11:21,830 --> 00:11:23,870
El planificador

226
00:11:23,870 --> 00:11:25,610
El planificador es el que tiene los datos

227
00:11:25,610 --> 00:11:27,129
Tiene

228
00:11:27,129 --> 00:11:29,789
Una lista de procesos pendientes

229
00:11:29,789 --> 00:11:31,830
De ejecutar y un conjunto

230
00:11:31,830 --> 00:11:33,450
De procesos ejecutándose

231
00:11:33,450 --> 00:11:35,509
En ejecución, tiene los datos

232
00:11:35,509 --> 00:11:37,009
Tiene los datos

233
00:11:37,009 --> 00:11:39,830
Y además tiene métodos para hacer

234
00:11:39,830 --> 00:11:41,870
Cosas con esos datos

235
00:11:41,870 --> 00:11:43,509
Eso es lo que tiene el planificador

236
00:11:43,509 --> 00:11:45,529
Pues vamos a ver

237
00:11:45,529 --> 00:12:10,230
El planificador tiene los datos que son, como solamente los usa él en sus métodos, pues privados, una lista de procesos que estos eran los pendientes, ¿verdad?

238
00:12:10,230 --> 00:12:50,580
Sí. Y luego tiene un set de procesos en ejecución. Estos son sus datos. Vale. Vamos a hacer los métodos. Los métodos que trabajan con estos datos. Bueno, pues métodos. El primero, agregar un proceso pendiente dado su prioridad y su duración, que efectivamente son los únicos dos datos que se irán de fuera, que llegarán de fuera.

239
00:12:50,580 --> 00:13:10,440
Vale, pues entonces agregar un proceso pendiente, agregar proceso pendiente, este proceso que le manda el sistema operativo tiene una prioridad y una duración.

240
00:13:10,440 --> 00:13:16,129
Vale, pues vamos a instanciar un proceso

241
00:13:16,129 --> 00:13:18,610
Con esta prioridad y esa duración

242
00:13:18,610 --> 00:13:20,429
El PID ya lo generará solo

243
00:13:20,429 --> 00:13:21,110
El constructor

244
00:13:21,110 --> 00:13:23,529
El PID ya lo genera solo aquí

245
00:13:23,529 --> 00:13:27,529
Vamos a generar un proceso

246
00:13:27,529 --> 00:13:29,230
Y se lo vamos a añadir a la lista

247
00:13:29,230 --> 00:13:30,490
Pues venga

248
00:13:30,490 --> 00:13:34,190
Pendientes.add

249
00:13:34,190 --> 00:13:35,769
New

250
00:13:35,769 --> 00:13:40,240
Proceso

251
00:13:40,240 --> 00:13:42,620
Con esta prioridad

252
00:13:42,620 --> 00:13:44,720
Y con esta duración

253
00:13:44,720 --> 00:13:48,879
Y el constructor

254
00:13:48,879 --> 00:13:50,740
ya sabemos que es la ingenia adentro

255
00:13:50,740 --> 00:13:52,779
para asignarle el pit que sea

256
00:13:52,779 --> 00:13:57,399
vale

257
00:13:57,399 --> 00:14:00,419
pero la lista

258
00:14:00,419 --> 00:14:01,500
tiene que quedar en orden

259
00:14:01,500 --> 00:14:05,970
entonces aquí podríamos complicarnos mucho

260
00:14:05,970 --> 00:14:08,049
la vida recorriendo la

261
00:14:08,049 --> 00:14:09,889
lista para buscar la posición

262
00:14:09,889 --> 00:14:11,970
que en el que encontramos el último

263
00:14:11,970 --> 00:14:13,590
que es menor que ese y

264
00:14:13,590 --> 00:14:15,570
insertar en esa posición

265
00:14:15,570 --> 00:14:17,429
que la tiene una variante general de posición

266
00:14:17,429 --> 00:14:20,049
aquí podemos hacer mil cosas pero la más fácil

267
00:14:20,049 --> 00:14:22,009
es como el orden de

268
00:14:22,009 --> 00:14:24,009
prioridad ya lo tienen implementado

269
00:14:24,009 --> 00:14:36,289
los procesos, yo puedo usar el método sort de la lista y el método sort, si yo le paso

270
00:14:36,289 --> 00:14:45,470
nada, si no le paso nada, ¿él cómo me va a ordenar? Él me va a ordenar según el orden

271
00:14:45,470 --> 00:14:51,110
que tengan ellos, el suyo. Ellos tienen un orden natural, el que yo le he puesto aquí.

272
00:14:51,110 --> 00:14:54,509
pues entonces este me va a ordenar

273
00:14:54,509 --> 00:14:56,009
y va a dejar la lista ordenada por ese orden

274
00:14:56,009 --> 00:14:57,370
entonces yo ya tengo la garantía

275
00:14:57,370 --> 00:14:59,870
de que el primero de la lista

276
00:14:59,870 --> 00:15:01,669
se queda el más prioritario

277
00:15:01,669 --> 00:15:03,570
el primero en orden

278
00:15:03,570 --> 00:15:05,090
y se quedan todos ordenaditos

279
00:15:05,090 --> 00:15:07,669
vale, añado y reordeno

280
00:15:07,669 --> 00:15:10,169
si hace falta, añado y reordeno, esto es lo más fácil

281
00:15:10,169 --> 00:15:13,740
lo más fácil que no

282
00:15:13,740 --> 00:15:15,559
computacionalmente lo mejor, porque estamos

283
00:15:15,559 --> 00:15:17,399
ordenando todo el rato, reordenando

284
00:15:17,399 --> 00:15:19,480
sería casi más fácil buscar en qué posición

285
00:15:19,480 --> 00:15:21,519
toca insertar e insertarla en esa

286
00:15:21,519 --> 00:15:22,940
Pero bueno

287
00:15:22,940 --> 00:15:29,100
¿Vale? ¿Este método lo dejaríamos así?

288
00:15:33,620 --> 00:15:34,620
¿Sí? ¿Seguro?

289
00:15:36,379 --> 00:15:37,659
¿Vosotros veis esto?

290
00:15:38,200 --> 00:15:39,700
¿Y nos

291
00:15:39,700 --> 00:15:41,779
Da dolor de corazón?

292
00:15:46,059 --> 00:15:47,860
¿No veis ahí un null pointer

293
00:15:47,860 --> 00:15:48,940
Exception horroroso?

294
00:15:49,779 --> 00:15:52,100
Claro, la primera vez

295
00:15:52,100 --> 00:15:53,740
Que desde un main se agregue

296
00:15:53,740 --> 00:15:54,860
Un proceso pendiente

297
00:15:54,860 --> 00:15:57,220
¡Pum! Null pointer exception

298
00:15:57,220 --> 00:15:59,080
¿Vale? Entonces el problema llega con

299
00:15:59,080 --> 00:16:01,779
el primer proceso que se añada

300
00:16:01,779 --> 00:16:03,679
¿cómo se suele

301
00:16:03,679 --> 00:16:04,820
solucionar eso normalmente?

302
00:16:05,720 --> 00:16:07,740
lo inicializamos ahí para que

303
00:16:07,740 --> 00:16:09,759
esté ya creada una lista

304
00:16:09,759 --> 00:16:10,259
vacía

305
00:16:10,259 --> 00:16:13,059
estoy comprometiendo la

306
00:16:13,059 --> 00:16:16,159
la implementación

307
00:16:16,159 --> 00:16:17,299
pero bueno

308
00:16:17,299 --> 00:16:22,809
si no podría hacerlo por constructor

309
00:16:22,809 --> 00:16:24,509
hacerlo en el constructor

310
00:16:24,509 --> 00:16:28,399
muchas posibilidades

311
00:16:28,399 --> 00:16:30,460
pero lo importante es que identifiquemos el problema

312
00:16:30,460 --> 00:16:44,159
vale, aquí entre

313
00:16:44,159 --> 00:16:45,539
hashSet, treeSet

314
00:16:45,539 --> 00:16:49,600
en principio da un poco igual, ya sabemos las diferencias

315
00:16:49,600 --> 00:16:52,200
si ponemos un triset

316
00:16:52,200 --> 00:16:57,279
no hay ningún problema, podemos hacerlo con un triset

317
00:16:57,279 --> 00:17:00,820
no hay ningún problema, no hay ningún problema en este caso

318
00:17:00,820 --> 00:17:02,799
¿por qué? porque el triset ya sabemos

319
00:17:02,799 --> 00:17:06,579
que necesita que los objetos que se meten en él

320
00:17:06,579 --> 00:17:09,559
tengan un orden establecido, porque el triset lo usa

321
00:17:09,559 --> 00:17:11,779
para recolocarlos internamente

322
00:17:11,779 --> 00:17:14,380
pero como proceso tiene un orden establecido

323
00:17:14,380 --> 00:17:16,859
Este triset funcionaría perfectamente

324
00:17:16,859 --> 00:17:18,299
Que

325
00:17:18,299 --> 00:17:20,180
Y además

326
00:17:20,180 --> 00:17:22,119
A la hora de iterar por el triset

327
00:17:22,119 --> 00:17:24,680
Nos lo sacaría precisamente en ese orden

328
00:17:24,680 --> 00:17:25,579
¿Vale?

329
00:17:27,079 --> 00:17:28,720
Que esa es la ventaja del triset

330
00:17:28,720 --> 00:17:30,440
Que si vamos metiendo en un triset

331
00:17:30,440 --> 00:17:32,200
Independientemente

332
00:17:32,200 --> 00:17:34,680
De en qué orden vayamos metiendo

333
00:17:34,680 --> 00:17:36,480
Independientemente de qué orden vayamos metiendo

334
00:17:36,480 --> 00:17:37,160
En ejecución

335
00:17:37,160 --> 00:17:39,299
Me los iría, si yo itero

336
00:17:39,299 --> 00:17:42,200
Me los va a sacar

337
00:17:42,200 --> 00:17:44,319
En el orden

338
00:17:44,319 --> 00:17:45,160
este de aquí

339
00:17:45,160 --> 00:17:48,180
si eso me gusta porque voy a hacer

340
00:17:48,180 --> 00:17:50,440
listados

341
00:17:50,440 --> 00:17:52,500
de procesos por orden de prioridad

342
00:17:52,500 --> 00:17:56,240
pues bueno, si pongo

343
00:17:56,240 --> 00:17:56,859
haset

344
00:17:56,859 --> 00:17:59,920
¿qué es lo que tengo que tener cuidado?

345
00:18:00,920 --> 00:18:02,079
pues que entonces

346
00:18:02,079 --> 00:18:03,880
proceso tiene que tener

347
00:18:03,880 --> 00:18:04,940
hasco de equals

348
00:18:04,940 --> 00:18:07,819
porque si no tiene hasco de equals

349
00:18:07,819 --> 00:18:10,420
haset no sabe

350
00:18:10,420 --> 00:18:12,039
qué significa

351
00:18:12,039 --> 00:18:14,180
que un proceso sea igual a otro

352
00:18:14,180 --> 00:18:15,680
con lo cual dice

353
00:18:15,680 --> 00:18:17,240
Para mí va a ser igual solamente

354
00:18:17,240 --> 00:18:19,579
Si uno es directamente la misma

355
00:18:19,579 --> 00:18:20,700
Posición de memoria

356
00:18:20,700 --> 00:18:22,700
No que sean los mismos datos

357
00:18:22,700 --> 00:18:23,960
Que son dos cosas distintas

358
00:18:23,960 --> 00:18:25,720
Entonces, ¿qué uso HASHET?

359
00:18:26,200 --> 00:18:27,500
Pues si usamos HASHET

360
00:18:27,500 --> 00:18:30,240
Esto no se nos puede olvidar

361
00:18:30,240 --> 00:18:35,160
Generar HASHCODE equals por aquello

362
00:18:35,160 --> 00:18:36,839
Que lo caracterice de forma única

363
00:18:36,839 --> 00:18:39,319
Que en este caso es el identificador de proceso

364
00:18:39,319 --> 00:18:40,940
Lo que lo caracteriza de forma única

365
00:18:40,940 --> 00:18:42,400
¿Vale?

366
00:18:45,789 --> 00:18:47,910
Pues ya está, entonces teniendo HASHCODE equal

367
00:18:47,910 --> 00:18:48,730
Y teniendo comparable

368
00:18:48,730 --> 00:18:51,650
aquí me da igual poner triset que haset

369
00:18:51,650 --> 00:18:53,470
me da igual, va a funcionar

370
00:18:53,470 --> 00:18:55,529
exactamente igual, con la ventaja añadida de que

371
00:18:55,529 --> 00:18:57,470
triset, si yo iterara

372
00:18:57,470 --> 00:18:59,329
me saldrían todos

373
00:18:59,329 --> 00:19:01,450
los que están en ejecución por orden de prioridad

374
00:19:01,450 --> 00:19:03,269
pero el uso sería

375
00:19:03,269 --> 00:19:05,289
idéntico, el uso sería idéntico

376
00:19:05,289 --> 00:19:06,990
vale

377
00:19:06,990 --> 00:19:09,170
de hecho vamos a poner un triset porque

378
00:19:09,170 --> 00:19:11,349
como lo voy a usar, lo usaría exactamente igual

379
00:19:11,349 --> 00:19:13,529
que un haset, vamos a poner un triset

380
00:19:13,529 --> 00:19:14,210
para variar

381
00:19:14,210 --> 00:19:16,829
vale, entonces

382
00:19:16,829 --> 00:19:23,849
agregar proceso ya estaría

383
00:19:23,849 --> 00:19:25,690
que otro método nos queda

384
00:19:25,690 --> 00:19:27,569
ejecutar

385
00:19:27,569 --> 00:19:31,109
saca un proceso de la lista

386
00:19:31,109 --> 00:19:32,670
el de mayor prioridad

387
00:19:32,670 --> 00:19:34,950
afortunadamente está ordenada

388
00:19:34,950 --> 00:19:36,309
luego el de mayor prioridad es el primero

389
00:19:36,309 --> 00:19:39,890
imprime un mensajito

390
00:19:39,890 --> 00:19:42,950
y lo manda al conjunto de procesos

391
00:19:42,950 --> 00:19:43,670
en ejecución

392
00:19:43,670 --> 00:19:46,869
vale, pues venga, vamos a hacer el ejecutar

393
00:19:46,869 --> 00:19:50,069
public void

394
00:19:50,069 --> 00:19:50,990
De ejecutar

395
00:19:50,990 --> 00:19:53,450
¿Dónde vas?

396
00:19:59,740 --> 00:20:01,079
Vale, ejecutar

397
00:20:01,079 --> 00:20:04,900
Vamos a sacar el primero de todos

398
00:20:04,900 --> 00:20:07,220
De todos, para añadirlo a la ejecución

399
00:20:07,220 --> 00:20:09,059
El primero de todos que se me va a prioritario

400
00:20:09,059 --> 00:20:10,839
Bueno, pues entonces

401
00:20:10,839 --> 00:20:12,480
Podríamos hacer directamente

402
00:20:12,480 --> 00:20:14,480
Ejecución

403
00:20:14,480 --> 00:20:17,039
Punto add

404
00:20:17,039 --> 00:20:19,900
Pendientes

405
00:20:19,900 --> 00:20:21,339
Punto get

406
00:20:21,339 --> 00:20:22,380
Fero

407
00:20:22,380 --> 00:20:25,660
hala, ya he hecho la primera parte

408
00:20:25,660 --> 00:20:27,559
que es añadir

409
00:20:27,559 --> 00:20:29,720
a la lista de procesos en ejecución

410
00:20:29,720 --> 00:20:31,759
el más prioritario

411
00:20:31,759 --> 00:20:32,299
de todos

412
00:20:32,299 --> 00:20:35,279
que es el que está en posición cero

413
00:20:35,279 --> 00:20:37,660
y ahora ya vamos

414
00:20:37,660 --> 00:20:38,299
a borrarlo

415
00:20:38,299 --> 00:20:40,440
ahora ya vamos a borrarlo

416
00:20:40,440 --> 00:20:43,559
pues dependientes.remove

417
00:20:44,160 --> 00:20:45,380
cero

418
00:20:45,380 --> 00:20:47,880
vale

419
00:20:47,880 --> 00:20:49,960
y ya está

420
00:20:49,960 --> 00:20:52,440
primero lo añado sin eliminarlo

421
00:20:52,440 --> 00:20:54,299
Y ahora lo borro

422
00:20:54,299 --> 00:20:57,140
¿Vale? Borro el de posición 0

423
00:20:57,140 --> 00:21:11,569
Aquí cuidado

424
00:21:11,569 --> 00:21:13,450
Con ciertos matices, por ejemplo

425
00:21:13,450 --> 00:21:15,650
Imaginad que lo habéis hecho así

426
00:21:15,650 --> 00:21:19,750
Que algunos habéis hecho, por ejemplo, esto

427
00:21:19,750 --> 00:21:21,650
Voy a sacar primero

428
00:21:21,650 --> 00:21:23,430
El proceso que toca

429
00:21:23,430 --> 00:21:25,450
Que habéis hecho esto

430
00:21:25,450 --> 00:21:26,109
Que está bien

431
00:21:26,109 --> 00:21:29,329
Pendientes.get 0

432
00:21:29,329 --> 00:21:31,410
Vale, ese es el que toca

433
00:21:31,410 --> 00:21:33,990
Ahora, se lo voy a añadir

434
00:21:33,990 --> 00:21:34,849
A ejecución

435
00:21:34,849 --> 00:21:36,670
ejecución

436
00:21:36,670 --> 00:21:37,349
punto

437
00:21:37,349 --> 00:21:40,609
add p, muy bien

438
00:21:40,609 --> 00:21:42,230
vale, hasta ahí bien

439
00:21:42,230 --> 00:21:44,410
y ahora, cuidado con

440
00:21:44,410 --> 00:21:45,410
que hagáis esto

441
00:21:45,410 --> 00:21:48,660
pendientes

442
00:21:48,660 --> 00:21:51,900
bueno, no, también funcionaría

443
00:21:51,900 --> 00:21:53,799
a ver, porque

444
00:21:53,799 --> 00:21:56,220
por ejemplo

445
00:21:56,220 --> 00:21:56,740
esto

446
00:21:56,740 --> 00:21:59,779
vale, eso también lo

447
00:21:59,779 --> 00:22:01,779
podríamos hacer, lógicamente, borramos este

448
00:22:01,779 --> 00:22:02,660
proceso, vale

449
00:22:02,660 --> 00:22:05,460
siempre ojo con el remove

450
00:22:05,460 --> 00:22:06,740
¿El remove qué hace?

451
00:22:07,539 --> 00:22:13,960
Busca un proceso igual a este en la lista de pendientes y lo borra.

452
00:22:14,940 --> 00:22:17,420
Pero claro, el remove tiene que saber qué significa igual.

453
00:22:18,279 --> 00:22:19,680
¿Hemos hecho igual en proceso?

454
00:22:21,720 --> 00:22:23,940
Pendientes es una lista, por eso busca solo el equals.

455
00:22:24,660 --> 00:22:26,619
No, no hemos hecho el equals.

456
00:22:27,240 --> 00:22:28,619
Ah, perdón, lo hemos hecho en proceso.

457
00:22:28,619 --> 00:22:30,019
Vale, pues entonces ningún problema.

458
00:22:30,500 --> 00:22:31,619
Hemos hecho el equals en proceso.

459
00:22:31,619 --> 00:22:36,900
Si no tuviéramos hecho el equals en proceso

460
00:22:36,900 --> 00:22:39,180
El remove que busca

461
00:22:39,180 --> 00:22:43,799
Uno que sea exactamente la misma dirección de memoria

462
00:22:43,799 --> 00:22:46,460
En este caso funcionaría

463
00:22:46,460 --> 00:22:48,019
Porque pendiente es get0

464
00:22:48,019 --> 00:22:50,819
Su dirección de memoria se la he asignado a p

465
00:22:50,819 --> 00:22:53,720
Esto también funcionaría

466
00:22:53,720 --> 00:22:58,529
Es decir, esto de aquí

467
00:22:58,529 --> 00:23:01,710
Funcionaría

468
00:23:01,710 --> 00:23:04,170
Con o sin

469
00:23:04,170 --> 00:23:05,130
Equals

470
00:23:05,130 --> 00:23:08,210
Esto funcionaría

471
00:23:08,210 --> 00:23:09,269
Con o sin equals

472
00:23:09,269 --> 00:23:10,710
¿Vale?

473
00:23:11,930 --> 00:23:14,150
Porque la dirección

474
00:23:14,150 --> 00:23:16,269
De p es la misma dirección

475
00:23:16,269 --> 00:23:18,109
De memoria que esta, le he asignado uno

476
00:23:18,109 --> 00:23:19,529
A la otra, la misma dirección de memoria

477
00:23:19,529 --> 00:23:21,910
Luego aunque yo no tenga el equals

478
00:23:21,910 --> 00:23:23,329
Al tirar del equals de object

479
00:23:23,329 --> 00:23:25,589
El equals de object es dirección de memoria igual

480
00:23:25,589 --> 00:23:30,109
Funcionaría, ¿vale?

481
00:23:30,109 --> 00:23:32,029
Esto no funcionaría

482
00:23:32,029 --> 00:23:32,789
Lógicamente

483
00:23:32,789 --> 00:23:36,190
Esto

484
00:23:36,190 --> 00:23:39,210
Solo funcionaría

485
00:23:39,210 --> 00:23:41,750
Con equals

486
00:23:41,750 --> 00:23:43,369
En proceso, lo que vamos a hacer ahora

487
00:23:43,369 --> 00:23:45,950
Esto, que sería un poco de retorcido

488
00:23:45,950 --> 00:23:47,349
Pero podríamos venir de otro método

489
00:23:47,349 --> 00:23:48,809
Y haber llegado a esto, por lo que fuera

490
00:23:48,809 --> 00:23:52,009
Hacer un proceso p igualito a este otro

491
00:23:52,009 --> 00:23:53,750
New proceso

492
00:23:54,329 --> 00:23:57,660
De

493
00:23:57,660 --> 00:24:04,250
Hacemos un new

494
00:24:04,250 --> 00:24:06,069
Proceso

495
00:24:06,069 --> 00:24:19,539
pendientes.getCero.getPrioridad

496
00:24:19,539 --> 00:24:33,549
pendientes.getCero.getDuración

497
00:24:33,549 --> 00:24:35,650
y me falta el otro parámetro

498
00:24:35,650 --> 00:24:39,549
y sería p.setPid

499
00:24:39,549 --> 00:24:43,609
pendientes

500
00:24:43,609 --> 00:24:48,480
get cero

501
00:24:48,480 --> 00:24:50,759
punto get

502
00:24:50,759 --> 00:24:51,220
pid

503
00:24:51,220 --> 00:24:56,660
vale, vale

504
00:24:56,660 --> 00:24:57,299
entonces

505
00:24:57,299 --> 00:25:11,039
vale, entonces

506
00:25:11,039 --> 00:25:12,960
en esta situación

507
00:25:12,960 --> 00:25:15,200
en esta, esta ya si que es muy

508
00:25:15,200 --> 00:25:15,839
distinta

509
00:25:15,839 --> 00:25:19,319
daos cuenta de esto, aquí me estoy haciendo

510
00:25:19,319 --> 00:25:21,380
un proceso con los

511
00:25:21,380 --> 00:25:23,319
mismos datos de este, con los

512
00:25:23,319 --> 00:25:24,859
mismos datos, con los mismos

513
00:25:24,859 --> 00:25:27,140
su privacidad es la misma, su dación es la misma

514
00:25:27,140 --> 00:25:28,279
y su PID es el mismo

515
00:25:28,279 --> 00:25:31,259
un proceso con los mismos datos, idéntico

516
00:25:31,259 --> 00:25:33,079
pero está, es otro objeto

517
00:25:33,079 --> 00:25:34,160
en otra dirección de memoria

518
00:25:34,160 --> 00:25:36,660
en la dirección de memoria PR, otro objeto

519
00:25:36,660 --> 00:25:38,400
mismos datos, idéntico

520
00:25:38,400 --> 00:25:41,299
esta parte estaría muy bien

521
00:25:41,299 --> 00:25:43,140
yo añado un proceso idéntico

522
00:25:43,140 --> 00:25:44,880
a ese ART, no pasa nada

523
00:25:44,880 --> 00:25:46,779
y está ese proceso con los datos, que es lo que me importa

524
00:25:46,779 --> 00:25:47,799
lo que importa son los datos

525
00:25:47,799 --> 00:25:50,680
y ahora voy a borrarlo de aquí

526
00:25:50,680 --> 00:25:53,279
pues este se va a buscar

527
00:25:53,279 --> 00:25:54,400
uno igual a este

528
00:25:54,400 --> 00:25:57,339
Si yo tengo el equals, estupendo

529
00:25:57,339 --> 00:25:59,119
Porque en cuanto encuentre uno

530
00:25:59,119 --> 00:26:01,480
Que tenga el mismo PID que este otro

531
00:26:01,480 --> 00:26:01,920
Borrado

532
00:26:01,920 --> 00:26:04,359
Si no tengo el equals en proceso

533
00:26:04,359 --> 00:26:05,980
Esto no borra nada

534
00:26:05,980 --> 00:26:09,259
Por mucho que este proceso

535
00:26:09,259 --> 00:26:12,740
Tenga los mismos datos

536
00:26:12,740 --> 00:26:14,000
Que el que yo quiero borrar

537
00:26:14,000 --> 00:26:15,599
Por mucho que tenga los mismos datos

538
00:26:15,599 --> 00:26:17,259
Como ese objeto no está abriendo memoria

539
00:26:17,259 --> 00:26:19,839
Esto no borraría nada

540
00:26:19,839 --> 00:26:21,480
¿Vale? Entonces

541
00:26:21,480 --> 00:26:31,400
Sí, pero es que aquí mira como lo he creado

542
00:26:31,400 --> 00:26:34,960
Es que le he asignado directamente este

543
00:26:34,960 --> 00:26:36,900
Luego es la misma dirección de memoria

544
00:26:36,900 --> 00:26:42,559
Claro, no, no, no

545
00:26:42,559 --> 00:26:44,640
Pero claro, él va a tirar del equal

546
00:26:44,640 --> 00:26:45,680
Si no tiene el equals

547
00:26:45,680 --> 00:26:46,779
Va a tirar

548
00:26:46,779 --> 00:26:51,000
Claro, pero por eso digo

549
00:26:51,000 --> 00:26:53,420
Pero este, si yo no tengo el equals hecho

550
00:26:53,420 --> 00:26:55,559
También me va a funcionar

551
00:26:55,559 --> 00:26:57,460
Porque entonces coge el equals de object

552
00:26:57,460 --> 00:26:59,960
Y el equals de object me busca

553
00:26:59,960 --> 00:27:02,200
uno que sea dirección de memoria

554
00:27:02,200 --> 00:27:04,279
idéntica que este, y este es dirección

555
00:27:04,279 --> 00:27:06,019
de memoria idéntica, entonces me borra este

556
00:27:06,019 --> 00:27:08,240
que es el que quiero borrar, sin embargo

557
00:27:08,240 --> 00:27:09,660
aquí si no tengo el equals

558
00:27:09,660 --> 00:27:12,019
en proceso, me tira del

559
00:27:12,019 --> 00:27:14,059
de object y busca uno

560
00:27:14,059 --> 00:27:15,819
que tenga dirección idéntica a este

561
00:27:15,819 --> 00:27:17,940
que no es este, ese no tiene

562
00:27:17,940 --> 00:27:19,779
dirección idéntica a ese, es otro

563
00:27:19,779 --> 00:27:21,059
con los mismos datos pero es otro

564
00:27:21,059 --> 00:27:24,160
¿vale? esa es la diferencia en las dos cosas

565
00:27:24,160 --> 00:27:26,000
¿vale?

566
00:27:26,900 --> 00:27:27,339
pero

567
00:27:27,339 --> 00:27:29,799
¿qué es lo más cómodo de hacer?

568
00:27:29,799 --> 00:27:30,700
Pues esto que hemos hecho aquí

569
00:27:30,700 --> 00:27:33,539
Que es borrar por posición, como yo sé que es el primero

570
00:27:33,539 --> 00:27:35,400
El que quiero borrar, borro por posición

571
00:27:35,400 --> 00:27:37,420
Borro cero y ya está, esto sería

572
00:27:37,420 --> 00:27:38,480
Lo más

573
00:27:38,480 --> 00:27:40,000
Vale

574
00:27:40,000 --> 00:27:42,559
Lo más cómodo de hacer

575
00:27:42,559 --> 00:27:58,470
Vale, esto sería lo más

576
00:27:58,470 --> 00:28:00,289
Cómodo, añado

577
00:28:00,289 --> 00:28:02,410
El de la primera posición y lo borro

578
00:28:02,410 --> 00:28:04,549
Por posición, porque el remove borra por posición

579
00:28:04,549 --> 00:28:06,450
Si hacéis un remove por posición

580
00:28:06,450 --> 00:28:08,109
Aquí el equals no importa nada

581
00:28:08,109 --> 00:28:09,990
Te borro de la posición, cero

582
00:28:09,990 --> 00:28:11,009
El equals me da igual

583
00:28:11,009 --> 00:28:17,869
Vale, y vamos a aprovechar y vamos a listar los procesos en ejecución que han quedado

584
00:28:17,869 --> 00:28:19,930
Para ver en qué orden me los muestra

585
00:28:19,930 --> 00:28:33,529
Procesos que se están ejecutando

586
00:28:33,529 --> 00:28:38,299
Vamos a ver los procesos que se están ejecutando

587
00:28:38,299 --> 00:28:42,640
Para cada proceso P en ejecución

588
00:28:42,640 --> 00:28:46,000
Vamos a mostrar

589
00:28:46,000 --> 00:28:48,779
Su

590
00:28:48,779 --> 00:28:50,319
Pit

591
00:28:50,319 --> 00:28:57,619
P.get pit

592
00:28:57,619 --> 00:28:59,839
Y vamos a mostrar

593
00:28:59,839 --> 00:29:02,940
Su

594
00:29:02,940 --> 00:29:05,819
Prioridad

595
00:29:05,819 --> 00:29:06,519
Y duración

596
00:29:06,519 --> 00:29:09,200
Para ver en que orden me lo está sacando

597
00:29:09,200 --> 00:29:11,900
Su prioridad

598
00:29:11,900 --> 00:29:23,160
P.get

599
00:29:23,160 --> 00:29:25,539
Prioridad

600
00:29:25,539 --> 00:29:26,599
Más

601
00:29:26,599 --> 00:29:49,880
Duración

602
00:29:49,880 --> 00:29:58,369
Vale, que me muestre los que se están ejecutando

603
00:29:58,369 --> 00:30:04,700
Vale, vamos a hacer un main

604
00:30:04,700 --> 00:30:06,539
Para probar esto, a ver si hemos metido la pata

605
00:30:06,539 --> 00:30:08,779
Y luego paramos si queréis un ratito

606
00:30:08,779 --> 00:30:09,420
Antes de seguir

607
00:30:09,420 --> 00:30:12,299
Vamos a hacer el main y ahora paramos un ratito

608
00:30:12,299 --> 00:30:14,819
Para que no se nos olvide lo que queremos probar

609
00:30:14,819 --> 00:30:18,579
A ver, el main lo voy a hacer

610
00:30:18,579 --> 00:30:20,380
En el propio planificador de procesos

611
00:30:20,380 --> 00:30:21,880
Así

612
00:30:21,880 --> 00:30:23,480
Ahorro clases

613
00:30:23,480 --> 00:30:26,519
Vale, me voy a hacer aquí

614
00:30:26,519 --> 00:30:27,240
Un main

615
00:30:27,240 --> 00:30:37,750
Y ahora, venga

616
00:30:37,750 --> 00:30:42,750
Vamos a crear un nuevo planificador

617
00:30:42,750 --> 00:30:55,480
Este es mi nuevo planificador con procesos vacíos

618
00:30:55,480 --> 00:31:04,779
Vamos a añadirle unos cuantos pendientes

619
00:31:04,779 --> 00:31:07,940
Así sea menor que...

620
00:31:07,940 --> 00:31:10,980
Vamos a añadirle 10

621
00:31:10,980 --> 00:31:12,299
Como lo vamos a hacer aleatoriamente

622
00:31:12,299 --> 00:31:18,259
Vamos a añadirle al planificador

623
00:31:18,259 --> 00:31:20,519
Agregar proceso pendiente

624
00:31:20,519 --> 00:31:22,700
Con prioridad

625
00:31:22,700 --> 00:31:24,720
Como podía ser solo entre 1 y 10

626
00:31:24,720 --> 00:31:30,390
Pues que sea esto

627
00:31:30,390 --> 00:31:31,289
Más

628
00:31:31,289 --> 00:31:37,049
Agregar proceso pendiente

629
00:31:37,049 --> 00:31:40,049
Más punto random

630
00:31:40,049 --> 00:31:42,869
Por 10 por ejemplo

631
00:31:42,869 --> 00:31:46,049
Y la duración

632
00:31:46,049 --> 00:31:48,430
Una aleatoria

633
00:31:48,430 --> 00:31:51,210
La duración no tenía restricciones

634
00:31:51,210 --> 00:31:56,009
Pues duración 100

635
00:31:56,009 --> 00:31:59,269
Entre 0 y 100 aprox

636
00:31:59,269 --> 00:32:03,210
Vale, estamos agregando 10 procesos pendientes

637
00:32:03,210 --> 00:32:05,869
De prioridades y duraciones aleatorias

638
00:32:05,869 --> 00:32:14,140
Vale, vamos a listarlos

639
00:32:14,140 --> 00:32:18,559
A ver si me aparecen ordenados

640
00:32:18,559 --> 00:32:23,109
Procesos pendientes

641
00:32:23,109 --> 00:32:26,380
Vamos a listarlos

642
00:32:26,380 --> 00:32:32,680
for proceso

643
00:32:32,680 --> 00:32:33,819
p en

644
00:32:33,819 --> 00:32:36,440
plan punto

645
00:32:36,440 --> 00:32:38,900
pendientes

646
00:32:38,900 --> 00:32:40,500
no he hecho ni get pero bueno

647
00:32:40,500 --> 00:32:41,740
como sea la misma clase da igual

648
00:32:41,740 --> 00:32:43,660
es un main solo para probar

649
00:32:43,660 --> 00:32:46,099
vamos a probar los pendientes

650
00:32:46,099 --> 00:32:50,569
pues vamos a mostrar

651
00:32:50,569 --> 00:32:52,589
todo esto

652
00:32:52,589 --> 00:33:04,410
vale vamos a probar primero este

653
00:33:04,410 --> 00:33:06,569
main que me agrega 10 con datos

654
00:33:06,569 --> 00:33:07,309
aleatorios

655
00:33:07,309 --> 00:33:09,410
y luego me los muestra

656
00:33:09,410 --> 00:33:11,529
a ver si ordena la lista

657
00:33:11,529 --> 00:33:13,869
a ver si la lista está realmente ordenada

658
00:33:13,869 --> 00:33:15,789
porque si no

659
00:33:15,789 --> 00:33:16,990
hay algo que no está bien hecho

660
00:33:16,990 --> 00:33:30,099
pues sí, los ha agregado

661
00:33:30,099 --> 00:33:32,799
y los ha ido ordenando

662
00:33:32,799 --> 00:33:34,839
porque aquí aparecen por orden

663
00:33:34,839 --> 00:33:35,519
de prioridad

664
00:33:35,519 --> 00:33:38,519
y los que tienen la misma prioridad

665
00:33:38,519 --> 00:33:40,680
que ha coincidido estos cinco

666
00:33:40,680 --> 00:33:41,460
primeros

667
00:33:41,460 --> 00:33:43,619
por orden de

668
00:33:43,619 --> 00:33:46,819
duración inversa

669
00:33:46,819 --> 00:33:48,720
entonces sí

670
00:33:48,720 --> 00:33:50,880
según ha ido agregando los ha ido ordenando

671
00:33:50,880 --> 00:33:53,279
Porque esto está ordenado y no ha agregado en ese orden

672
00:33:53,279 --> 00:33:54,859
Porque los pids están ahí

673
00:33:54,859 --> 00:33:57,519
Salteados

674
00:33:57,519 --> 00:34:01,619
Vale, pues lo de agregar

675
00:34:01,619 --> 00:34:03,619
Proceso pendiente y que la lista se quede siempre

676
00:34:03,619 --> 00:34:04,180
Ordenada

677
00:34:04,180 --> 00:34:07,700
Está, parece que está bien

678
00:34:07,700 --> 00:34:09,199
Hecho, entonces vamos a parar ahora

679
00:34:09,199 --> 00:34:11,019
Y luego ya probamos esto de ejecutar

680
00:34:11,019 --> 00:34:11,980
Vale