Saltar navegación

20260303 Examen24feb_ejer2_1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 3 de marzo de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

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, 00:00:00
Y luego un planificador que hace cosas con esos procesos que los tiene guardados en dos colecciones dentro. 00:00:37
Entonces, lo primero, pues hacemos el proceso. 00:00:46
Vale, el proceso tiene su identificador de proceso, que tiene que ser entero. 00:00:47
Su identificador de proceso, prioridad y duración. 00:01:06
Todos enteros. 00:01:11
Pues, hala, todos aquí. 00:01:15
prioridad, aquí no había 00:01:17
nada de herencia ni de nada, esto era solo 00:01:19
para colecciones, ya está 00:01:21
entonces, les ponemos 00:01:22
un getter y setter 00:01:26
y ahora el constructor 00:01:28
el constructor nos lleva rápidamente a la idea 00:01:38
de qué pasa cuando este 00:01:40
proceso se genere, el constructor 00:01:42
ya sabemos qué es lo que se invoca 00:01:44
cuando el objeto se crea 00:01:46
vale, pues en ese momento 00:01:48
de crear el objeto, nos han dado alguna información 00:01:50
a tener en cuenta 00:01:52
pues sí, nos han dicho 00:01:53
que la propiedad pit 00:01:57
esta, el identificador del proceso 00:01:59
se tiene que generar 00:02:01
automáticamente cuando el proceso se crea 00:02:02
es decir, no se da desde 00:02:05
fuera, como la prioridad y la duración 00:02:06
no se da, sino que se genera automáticamente 00:02:09
por la aplicación 00:02:11
eso nos lleva 00:02:12
a decidir 00:02:14
que nuestro constructor entonces 00:02:16
tiene dos parámetros, nuestro constructor 00:02:18
va a tener solo dos parámetros, este 00:02:20
y este, porque el 00:02:22
pit no se pasa desde fuera 00:02:24
vale, pues este es nuestro constructor 00:02:26
con estos 00:02:32
dos parámetros, pero 00:02:34
claro, el identificador de proceso 00:02:36
que es lo que lo caracteriza de forma 00:02:38
lo que lo identifica de forma única 00:02:40
pues tiene que generarse 00:02:42
entonces, ¿cuál? ¿el que nos dé la gana a nosotros? 00:02:44
a ver, no puedo poner yo de repente 00:02:48
aquí uno random 00:02:50
así 00:02:51
diciendo, bueno, vale, pues este 00:02:53
efectivamente es uno 00:02:58
entero 00:03:00
con esto no tengo la garantía 00:03:02
de que vayan a ser únicos, no lo tengo 00:03:05
porque se puede repetir la aleatoriedad 00:03:07
entonces, tenemos 00:03:09
que hacer alguna otra cosa, bueno, pues 00:03:11
eso, solo hay una 00:03:13
manera, que es tomar una 00:03:15
semilla, un algo 00:03:17
una variable, una variable 00:03:18
que sea la generadora de pits 00:03:21
que sea la generadora 00:03:22
esa variable ¿dónde la colocamos? 00:03:23
pues bueno, uno podría hacer una clase 00:03:27
aparte para poner esa especie 00:03:28
de variable, variable que 00:03:30
tiene que ser una variable que conserve su valor 00:03:32
global, pues tendrá que ser estática 00:03:34
eso es lo que nos viene a la cabeza cuando pensamos en una variable 00:03:36
que conserva ahí su valor, que es la que me da 00:03:38
la información del siguiente 00:03:40
PID a usar 00:03:43
la puedo meter en una clase aparte 00:03:44
pero bueno, como esa información, esa variable 00:03:46
está relacionada exclusivamente 00:03:48
con procesos, pues para qué 00:03:50
voy a crear una clase aparte por esa, la coloco aquí. 00:03:52
Vale, pues venga, la coloco aquí y ya está. 00:03:55
Y me hago yo aquí mi variable estática, por ejemplo, esta. 00:03:58
Inicialmente, cero. 00:04:10
A ver, siguiente, pit, quería yo poner. 00:04:14
Vale, como solo la voy a usar, solo la voy a usar desde esta clase, 00:04:22
solo la voy a usar aquí, la puedo poner como privada, 00:04:26
pero solo la voy a usar aquí. 00:04:28
Y ahora esta variable global que está aquí alojada 00:04:29
Porque todas las variables tienen que estar alojadas en una clase 00:04:32
Pues esta que está aquí alojada 00:04:35
La uso yo de esta manera, por ejemplo 00:04:37
Y ya está 00:04:42
Entonces cada proceso que se construya 00:04:44
Tiene un identificador distinto 00:04:47
Y ese generador de identificadores 00:04:50
Ese generador de identificadores 00:04:52
Pues lo alojo aquí en esta variable estática y ya está 00:04:57
¿Vale? Por ejemplo aquí 00:05:00
Entonces la primera vez 00:05:02
Que se cree un proceso 00:05:07
La primera vez que se cree 00:05:10
Para el primer proceso 00:05:12
Es cuando se crea esta variable estática 00:05:13
La primera vez 00:05:15
Que se creará con cero 00:05:17
¿Vale? 00:05:18
Con lo cual el primer proceso se le pone un cero 00:05:20
Y esa variable estática ya se queda ahí 00:05:23
Y cuando se crea un siguiente proceso 00:05:25
No se vuelve a crear esta variable 00:05:28
Porque esa ya era una variable estática 00:05:30
con lo cual ya estaba creada 00:05:32
para el otro y es común para todos 00:05:34
entonces esa no se vuelve a crear con 0 otra vez 00:05:36
¿vale? no se vuelve a crear con 0 00:05:38
entonces 00:05:40
el siguiente proceso que se cree 00:05:42
accederá a esta variable 00:05:44
que tendrá un 1 porque se quedó incrementada 00:05:46
del anterior 00:05:48
¿vale? y el siguiente proceso que se cree 00:05:49
pues tendrá, accederá a esta variable 00:05:52
que no se ha creado de nuevas 00:05:54
se creará de nuevas si no tuviera el static 00:05:56
pero es que tiene el static 00:05:58
luego no se ha creado de nuevas, se crea 00:06:00
cuando se crea el primer objeto 00:06:02
y ahí ya se queda para siempre 00:06:03
porque es común para todos, no se vuelve a crear cada vez 00:06:05
¿vale? eso era una variable estática 00:06:08
bueno, pues vuestra es la manera más cómoda 00:06:10
vale, pues entonces 00:06:14
¿el proceso tiene algo más? 00:06:16
nada 00:06:18
tenemos un constructor 00:06:19
que garantiza esta condición que nos han dicho 00:06:21
garantiza esta, vale 00:06:24
ahora, ¿qué más nos dicen? 00:06:25
los procesos tienen un orden 00:06:28
tienen un orden 00:06:29
Ah bueno, pues si los procesos implementan un orden 00:06:31
Implementar un orden 00:06:33
Ya nos sale, pues vamos a implementar comparable 00:06:34
Los procesos implementan este orden 00:06:37
Vale, y ese orden cuál va a ser 00:06:39
Por prioridad, pero si la prioridad es igual 00:06:41
Por duración 00:06:43
Asumimos entonces que no hay dos procesos 00:06:44
De misma prioridad y misma duración 00:06:47
Y si lo hay, pues son 00:06:48
El mismo 00:06:51
Venga 00:06:53
Está en la misma posición, perdón 00:06:54
Vale, pues entonces, al implementar un orden 00:06:57
Pues vamos a hacer que implemente el comparable 00:06:59
Para poder ser comparado con otro proceso 00:07:04
Para poder ser comparado con otro proceso 00:07:13
¿Cuál es la diferencia entre comparable y comparado? 00:07:17
200.000 veces lo tengo que explicar 00:07:23
Bueno, ahora como en este también hay que hacer un comparator 00:07:24
Ahora lo hacemos 00:07:30
¿Vale? 00:07:31
Entonces, comparable es una capacidad que tiene una entidad, que es la capacidad de ser comparado con otro. 00:07:32
Entonces, ¿quiénes implementan comparable? 00:07:41
Las entidades de mi aplicación, las mesas, pueden ser comparables o no, porque pueden ser comparadas en orden con otras mesas. 00:07:43
Los alumnos, clase alumno puede implementar comparable o no, porque puedo ponerle yo en orden con otro alumno, ¿vale? 00:07:50
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? 00:07:57
vale, bueno, pues vamos a implementar 00:08:22
aquí, entonces, si implementamos 00:08:25
comparable hay que decir, oye, vale 00:08:27
pues, ¿qué hace 00:08:29
que tú estés por delante o por 00:08:31
detrás de otro? ¿qué es lo que hace? 00:08:33
pues lo que lo diga el método compare tú 00:08:35
el método compare tú es el que te dice 00:08:37
si tú vas antes o después de otro 00:08:41
¿cómo? pues aquí estamos 00:08:43
comparando el objeto dis 00:08:45
estamos comparando dis 00:08:46
¿con quién lo estamos comparando? 00:08:49
Con O 00:08:52
Comparamos 00:08:53
Dis 00:08:55
Con O 00:08:58
¿Vale? A ver cuál va antes 00:09:00
Y cuál va después, con este 00:09:02
Pues depende de la prioridad 00:09:04
En orden 00:09:06
¿Cuál era ascendente o descendente de prioridad? 00:09:09
En orden, supongo que ascendente 00:09:12
Pues entonces 00:09:14
Comparamos Dis con O, entonces 00:09:15
Si la prioridad es distinta, es decir, si this.prioridad es distinta de o.prioridad, pues entonces está claro. 00:09:18
return o.prioridad menos this.prioridad. 00:09:35
Vamos a verificar. 00:09:43
Ahora, si el proceso dis que llama al compare tú tiene más prioridad que el parámetro, esto es negativo. 00:09:45
Negativo significa que va antes, justo, va antes el de más prioridad. 00:09:57
Vale, si el proceso que llama tiene menos prioridad que este, esta resta es positiva. 00:10:02
Positiva significa ir después, justo. 00:10:10
Si tiene menos, vas después. 00:10:12
Vale, ¿y qué pasa si no es la misma? 00:10:13
Perdón, que si no es distinta 00:10:21
Si no es distinta, pues la duración 00:10:22
El de menor duración primero 00:10:25
Entonces el de menor duración primero será 00:10:30
Dis.duración menos o.duración 00:10:32
¿Verdad? 00:10:40
Si este que lo llama tiene menos duración 00:10:42
Esta resta es negativa 00:10:46
Luego va primero 00:10:48
Que eso es lo que significa devolver negativo 00:10:49
Si este que lo llama 00:10:51
Tiene más duración 00:10:54
Esta resta es positiva 00:10:55
Luego va después 00:10:57
Que es lo que significa dar positivo 00:10:58
Pues ya está 00:11:00
Entonces mis procesos 00:11:02
Implementan el rol 00:11:04
El papel de ser comparables 00:11:07
Con otros 00:11:10
Y su criterio de comparación es este 00:11:11
Vale, seguimos 00:11:13
Ya está, en proceso no hay más que hacer 00:11:17
El planificador 00:11:21
El planificador es el que tiene los datos 00:11:23
Tiene 00:11:25
Una lista de procesos pendientes 00:11:27
De ejecutar y un conjunto 00:11:29
De procesos ejecutándose 00:11:31
En ejecución, tiene los datos 00:11:33
Tiene los datos 00:11:35
Y además tiene métodos para hacer 00:11:37
Cosas con esos datos 00:11:39
Eso es lo que tiene el planificador 00:11:41
Pues vamos a ver 00:11:43
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? 00:11:45
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. 00:12:10
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. 00:12:50
Vale, pues vamos a instanciar un proceso 00:13:10
Con esta prioridad y esa duración 00:13:16
El PID ya lo generará solo 00:13:18
El constructor 00:13:20
El PID ya lo genera solo aquí 00:13:21
Vamos a generar un proceso 00:13:23
Y se lo vamos a añadir a la lista 00:13:27
Pues venga 00:13:29
Pendientes.add 00:13:30
New 00:13:34
Proceso 00:13:35
Con esta prioridad 00:13:40
Y con esta duración 00:13:42
Y el constructor 00:13:44
ya sabemos que es la ingenia adentro 00:13:48
para asignarle el pit que sea 00:13:50
vale 00:13:52
pero la lista 00:13:57
tiene que quedar en orden 00:14:00
entonces aquí podríamos complicarnos mucho 00:14:01
la vida recorriendo la 00:14:05
lista para buscar la posición 00:14:08
que en el que encontramos el último 00:14:09
que es menor que ese y 00:14:11
insertar en esa posición 00:14:13
que la tiene una variante general de posición 00:14:15
aquí podemos hacer mil cosas pero la más fácil 00:14:17
es como el orden de 00:14:20
prioridad ya lo tienen implementado 00:14:22
los procesos, yo puedo usar el método sort de la lista y el método sort, si yo le paso 00:14:24
nada, si no le paso nada, ¿él cómo me va a ordenar? Él me va a ordenar según el orden 00:14:36
que tengan ellos, el suyo. Ellos tienen un orden natural, el que yo le he puesto aquí. 00:14:45
pues entonces este me va a ordenar 00:14:51
y va a dejar la lista ordenada por ese orden 00:14:54
entonces yo ya tengo la garantía 00:14:56
de que el primero de la lista 00:14:57
se queda el más prioritario 00:14:59
el primero en orden 00:15:01
y se quedan todos ordenaditos 00:15:03
vale, añado y reordeno 00:15:05
si hace falta, añado y reordeno, esto es lo más fácil 00:15:07
lo más fácil que no 00:15:10
computacionalmente lo mejor, porque estamos 00:15:13
ordenando todo el rato, reordenando 00:15:15
sería casi más fácil buscar en qué posición 00:15:17
toca insertar e insertarla en esa 00:15:19
Pero bueno 00:15:21
¿Vale? ¿Este método lo dejaríamos así? 00:15:22
¿Sí? ¿Seguro? 00:15:33
¿Vosotros veis esto? 00:15:36
¿Y nos 00:15:38
Da dolor de corazón? 00:15:39
¿No veis ahí un null pointer 00:15:46
Exception horroroso? 00:15:47
Claro, la primera vez 00:15:49
Que desde un main se agregue 00:15:52
Un proceso pendiente 00:15:53
¡Pum! Null pointer exception 00:15:54
¿Vale? Entonces el problema llega con 00:15:57
el primer proceso que se añada 00:15:59
¿cómo se suele 00:16:01
solucionar eso normalmente? 00:16:03
lo inicializamos ahí para que 00:16:05
esté ya creada una lista 00:16:07
vacía 00:16:09
estoy comprometiendo la 00:16:10
la implementación 00:16:13
pero bueno 00:16:16
si no podría hacerlo por constructor 00:16:17
hacerlo en el constructor 00:16:22
muchas posibilidades 00:16:24
pero lo importante es que identifiquemos el problema 00:16:28
vale, aquí entre 00:16:30
hashSet, treeSet 00:16:44
en principio da un poco igual, ya sabemos las diferencias 00:16:45
si ponemos un triset 00:16:49
no hay ningún problema, podemos hacerlo con un triset 00:16:52
no hay ningún problema, no hay ningún problema en este caso 00:16:57
¿por qué? porque el triset ya sabemos 00:17:00
que necesita que los objetos que se meten en él 00:17:02
tengan un orden establecido, porque el triset lo usa 00:17:06
para recolocarlos internamente 00:17:09
pero como proceso tiene un orden establecido 00:17:11
Este triset funcionaría perfectamente 00:17:14
Que 00:17:16
Y además 00:17:18
A la hora de iterar por el triset 00:17:20
Nos lo sacaría precisamente en ese orden 00:17:22
¿Vale? 00:17:24
Que esa es la ventaja del triset 00:17:27
Que si vamos metiendo en un triset 00:17:28
Independientemente 00:17:30
De en qué orden vayamos metiendo 00:17:32
Independientemente de qué orden vayamos metiendo 00:17:34
En ejecución 00:17:36
Me los iría, si yo itero 00:17:37
Me los va a sacar 00:17:39
En el orden 00:17:42
este de aquí 00:17:44
si eso me gusta porque voy a hacer 00:17:45
listados 00:17:48
de procesos por orden de prioridad 00:17:50
pues bueno, si pongo 00:17:52
haset 00:17:56
¿qué es lo que tengo que tener cuidado? 00:17:56
pues que entonces 00:18:00
proceso tiene que tener 00:18:02
hasco de equals 00:18:03
porque si no tiene hasco de equals 00:18:04
haset no sabe 00:18:07
qué significa 00:18:10
que un proceso sea igual a otro 00:18:12
con lo cual dice 00:18:14
Para mí va a ser igual solamente 00:18:15
Si uno es directamente la misma 00:18:17
Posición de memoria 00:18:19
No que sean los mismos datos 00:18:20
Que son dos cosas distintas 00:18:22
Entonces, ¿qué uso HASHET? 00:18:23
Pues si usamos HASHET 00:18:26
Esto no se nos puede olvidar 00:18:27
Generar HASHCODE equals por aquello 00:18:30
Que lo caracterice de forma única 00:18:35
Que en este caso es el identificador de proceso 00:18:36
Lo que lo caracteriza de forma única 00:18:39
¿Vale? 00:18:40
Pues ya está, entonces teniendo HASHCODE equal 00:18:45
Y teniendo comparable 00:18:47
aquí me da igual poner triset que haset 00:18:48
me da igual, va a funcionar 00:18:51
exactamente igual, con la ventaja añadida de que 00:18:53
triset, si yo iterara 00:18:55
me saldrían todos 00:18:57
los que están en ejecución por orden de prioridad 00:18:59
pero el uso sería 00:19:01
idéntico, el uso sería idéntico 00:19:03
vale 00:19:05
de hecho vamos a poner un triset porque 00:19:06
como lo voy a usar, lo usaría exactamente igual 00:19:09
que un haset, vamos a poner un triset 00:19:11
para variar 00:19:13
vale, entonces 00:19:14
agregar proceso ya estaría 00:19:16
que otro método nos queda 00:19:23
ejecutar 00:19:25
saca un proceso de la lista 00:19:27
el de mayor prioridad 00:19:31
afortunadamente está ordenada 00:19:32
luego el de mayor prioridad es el primero 00:19:34
imprime un mensajito 00:19:36
y lo manda al conjunto de procesos 00:19:39
en ejecución 00:19:42
vale, pues venga, vamos a hacer el ejecutar 00:19:43
public void 00:19:46
De ejecutar 00:19:50
¿Dónde vas? 00:19:50
Vale, ejecutar 00:19:59
Vamos a sacar el primero de todos 00:20:01
De todos, para añadirlo a la ejecución 00:20:04
El primero de todos que se me va a prioritario 00:20:07
Bueno, pues entonces 00:20:09
Podríamos hacer directamente 00:20:10
Ejecución 00:20:12
Punto add 00:20:14
Pendientes 00:20:17
Punto get 00:20:19
Fero 00:20:21
hala, ya he hecho la primera parte 00:20:22
que es añadir 00:20:25
a la lista de procesos en ejecución 00:20:27
el más prioritario 00:20:29
de todos 00:20:31
que es el que está en posición cero 00:20:32
y ahora ya vamos 00:20:35
a borrarlo 00:20:37
ahora ya vamos a borrarlo 00:20:38
pues dependientes.remove 00:20:40
cero 00:20:44
vale 00:20:45
y ya está 00:20:47
primero lo añado sin eliminarlo 00:20:49
Y ahora lo borro 00:20:52
¿Vale? Borro el de posición 0 00:20:54
Aquí cuidado 00:20:57
Con ciertos matices, por ejemplo 00:21:11
Imaginad que lo habéis hecho así 00:21:13
Que algunos habéis hecho, por ejemplo, esto 00:21:15
Voy a sacar primero 00:21:19
El proceso que toca 00:21:21
Que habéis hecho esto 00:21:23
Que está bien 00:21:25
Pendientes.get 0 00:21:26
Vale, ese es el que toca 00:21:29
Ahora, se lo voy a añadir 00:21:31
A ejecución 00:21:33
ejecución 00:21:34
punto 00:21:36
add p, muy bien 00:21:37
vale, hasta ahí bien 00:21:40
y ahora, cuidado con 00:21:42
que hagáis esto 00:21:44
pendientes 00:21:45
bueno, no, también funcionaría 00:21:48
a ver, porque 00:21:51
por ejemplo 00:21:53
esto 00:21:56
vale, eso también lo 00:21:56
podríamos hacer, lógicamente, borramos este 00:21:59
proceso, vale 00:22:01
siempre ojo con el remove 00:22:02
¿El remove qué hace? 00:22:05
Busca un proceso igual a este en la lista de pendientes y lo borra. 00:22:07
Pero claro, el remove tiene que saber qué significa igual. 00:22:14
¿Hemos hecho igual en proceso? 00:22:18
Pendientes es una lista, por eso busca solo el equals. 00:22:21
No, no hemos hecho el equals. 00:22:24
Ah, perdón, lo hemos hecho en proceso. 00:22:27
Vale, pues entonces ningún problema. 00:22:28
Hemos hecho el equals en proceso. 00:22:30
Si no tuviéramos hecho el equals en proceso 00:22:31
El remove que busca 00:22:36
Uno que sea exactamente la misma dirección de memoria 00:22:39
En este caso funcionaría 00:22:43
Porque pendiente es get0 00:22:46
Su dirección de memoria se la he asignado a p 00:22:48
Esto también funcionaría 00:22:50
Es decir, esto de aquí 00:22:53
Funcionaría 00:22:58
Con o sin 00:23:01
Equals 00:23:04
Esto funcionaría 00:23:05
Con o sin equals 00:23:08
¿Vale? 00:23:09
Porque la dirección 00:23:11
De p es la misma dirección 00:23:14
De memoria que esta, le he asignado uno 00:23:16
A la otra, la misma dirección de memoria 00:23:18
Luego aunque yo no tenga el equals 00:23:19
Al tirar del equals de object 00:23:21
El equals de object es dirección de memoria igual 00:23:23
Funcionaría, ¿vale? 00:23:25
Esto no funcionaría 00:23:30
Lógicamente 00:23:32
Esto 00:23:32
Solo funcionaría 00:23:36
Con equals 00:23:39
En proceso, lo que vamos a hacer ahora 00:23:41
Esto, que sería un poco de retorcido 00:23:43
Pero podríamos venir de otro método 00:23:45
Y haber llegado a esto, por lo que fuera 00:23:47
Hacer un proceso p igualito a este otro 00:23:48
New proceso 00:23:52
Hacemos un new 00:23:57
Proceso 00:24:04
pendientes.getCero.getPrioridad 00:24:06
pendientes.getCero.getDuración 00:24:19
y me falta el otro parámetro 00:24:33
y sería p.setPid 00:24:35
pendientes 00:24:39
get cero 00:24:43
punto get 00:24:48
pid 00:24:50
vale, vale 00:24:51
entonces 00:24:56
vale, entonces 00:24:57
en esta situación 00:25:11
en esta, esta ya si que es muy 00:25:12
distinta 00:25:15
daos cuenta de esto, aquí me estoy haciendo 00:25:15
un proceso con los 00:25:19
mismos datos de este, con los 00:25:21
mismos datos, con los mismos 00:25:23
su privacidad es la misma, su dación es la misma 00:25:24
y su PID es el mismo 00:25:27
un proceso con los mismos datos, idéntico 00:25:28
pero está, es otro objeto 00:25:31
en otra dirección de memoria 00:25:33
en la dirección de memoria PR, otro objeto 00:25:34
mismos datos, idéntico 00:25:36
esta parte estaría muy bien 00:25:38
yo añado un proceso idéntico 00:25:41
a ese ART, no pasa nada 00:25:43
y está ese proceso con los datos, que es lo que me importa 00:25:44
lo que importa son los datos 00:25:46
y ahora voy a borrarlo de aquí 00:25:47
pues este se va a buscar 00:25:50
uno igual a este 00:25:53
Si yo tengo el equals, estupendo 00:25:54
Porque en cuanto encuentre uno 00:25:57
Que tenga el mismo PID que este otro 00:25:59
Borrado 00:26:01
Si no tengo el equals en proceso 00:26:01
Esto no borra nada 00:26:04
Por mucho que este proceso 00:26:05
Tenga los mismos datos 00:26:09
Que el que yo quiero borrar 00:26:12
Por mucho que tenga los mismos datos 00:26:14
Como ese objeto no está abriendo memoria 00:26:15
Esto no borraría nada 00:26:17
¿Vale? Entonces 00:26:19
Sí, pero es que aquí mira como lo he creado 00:26:21
Es que le he asignado directamente este 00:26:31
Luego es la misma dirección de memoria 00:26:34
Claro, no, no, no 00:26:36
Pero claro, él va a tirar del equal 00:26:42
Si no tiene el equals 00:26:44
Va a tirar 00:26:45
Claro, pero por eso digo 00:26:46
Pero este, si yo no tengo el equals hecho 00:26:51
También me va a funcionar 00:26:53
Porque entonces coge el equals de object 00:26:55
Y el equals de object me busca 00:26:57
uno que sea dirección de memoria 00:26:59
idéntica que este, y este es dirección 00:27:02
de memoria idéntica, entonces me borra este 00:27:04
que es el que quiero borrar, sin embargo 00:27:06
aquí si no tengo el equals 00:27:08
en proceso, me tira del 00:27:09
de object y busca uno 00:27:12
que tenga dirección idéntica a este 00:27:14
que no es este, ese no tiene 00:27:15
dirección idéntica a ese, es otro 00:27:17
con los mismos datos pero es otro 00:27:19
¿vale? esa es la diferencia en las dos cosas 00:27:21
¿vale? 00:27:24
pero 00:27:26
¿qué es lo más cómodo de hacer? 00:27:27
Pues esto que hemos hecho aquí 00:27:29
Que es borrar por posición, como yo sé que es el primero 00:27:30
El que quiero borrar, borro por posición 00:27:33
Borro cero y ya está, esto sería 00:27:35
Lo más 00:27:37
Vale 00:27:38
Lo más cómodo de hacer 00:27:40
Vale, esto sería lo más 00:27:42
Cómodo, añado 00:27:58
El de la primera posición y lo borro 00:28:00
Por posición, porque el remove borra por posición 00:28:02
Si hacéis un remove por posición 00:28:04
Aquí el equals no importa nada 00:28:06
Te borro de la posición, cero 00:28:08
El equals me da igual 00:28:09
Vale, y vamos a aprovechar y vamos a listar los procesos en ejecución que han quedado 00:28:11
Para ver en qué orden me los muestra 00:28:17
Procesos que se están ejecutando 00:28:19
Vamos a ver los procesos que se están ejecutando 00:28:33
Para cada proceso P en ejecución 00:28:38
Vamos a mostrar 00:28:42
Pit 00:28:48
P.get pit 00:28:50
Y vamos a mostrar 00:28:57
Prioridad 00:29:02
Y duración 00:29:05
Para ver en que orden me lo está sacando 00:29:06
Su prioridad 00:29:09
P.get 00:29:11
Prioridad 00:29:23
Más 00:29:25
Duración 00:29:26
Vale, que me muestre los que se están ejecutando 00:29:49
Vale, vamos a hacer un main 00:29:58
Para probar esto, a ver si hemos metido la pata 00:30:04
Y luego paramos si queréis un ratito 00:30:06
Antes de seguir 00:30:08
Vamos a hacer el main y ahora paramos un ratito 00:30:09
Para que no se nos olvide lo que queremos probar 00:30:12
A ver, el main lo voy a hacer 00:30:14
En el propio planificador de procesos 00:30:18
Así 00:30:20
Ahorro clases 00:30:21
Vale, me voy a hacer aquí 00:30:23
Un main 00:30:26
Y ahora, venga 00:30:27
Vamos a crear un nuevo planificador 00:30:37
Este es mi nuevo planificador con procesos vacíos 00:30:42
Vamos a añadirle unos cuantos pendientes 00:30:55
Así sea menor que... 00:31:04
Vamos a añadirle 10 00:31:07
Como lo vamos a hacer aleatoriamente 00:31:10
Vamos a añadirle al planificador 00:31:12
Agregar proceso pendiente 00:31:18
Con prioridad 00:31:20
Como podía ser solo entre 1 y 10 00:31:22
Pues que sea esto 00:31:24
Más 00:31:30
Agregar proceso pendiente 00:31:31
Más punto random 00:31:37
Por 10 por ejemplo 00:31:40
Y la duración 00:31:42
Una aleatoria 00:31:46
La duración no tenía restricciones 00:31:48
Pues duración 100 00:31:51
Entre 0 y 100 aprox 00:31:56
Vale, estamos agregando 10 procesos pendientes 00:31:59
De prioridades y duraciones aleatorias 00:32:03
Vale, vamos a listarlos 00:32:05
A ver si me aparecen ordenados 00:32:14
Procesos pendientes 00:32:18
Vamos a listarlos 00:32:23
for proceso 00:32:26
p en 00:32:32
plan punto 00:32:33
pendientes 00:32:36
no he hecho ni get pero bueno 00:32:38
como sea la misma clase da igual 00:32:40
es un main solo para probar 00:32:41
vamos a probar los pendientes 00:32:43
pues vamos a mostrar 00:32:46
todo esto 00:32:50
vale vamos a probar primero este 00:32:52
main que me agrega 10 con datos 00:33:04
aleatorios 00:33:06
y luego me los muestra 00:33:07
a ver si ordena la lista 00:33:09
a ver si la lista está realmente ordenada 00:33:11
porque si no 00:33:13
hay algo que no está bien hecho 00:33:15
pues sí, los ha agregado 00:33:16
y los ha ido ordenando 00:33:30
porque aquí aparecen por orden 00:33:32
de prioridad 00:33:34
y los que tienen la misma prioridad 00:33:35
que ha coincidido estos cinco 00:33:38
primeros 00:33:40
por orden de 00:33:41
duración inversa 00:33:43
entonces sí 00:33:46
según ha ido agregando los ha ido ordenando 00:33:48
Porque esto está ordenado y no ha agregado en ese orden 00:33:50
Porque los pids están ahí 00:33:53
Salteados 00:33:54
Vale, pues lo de agregar 00:33:57
Proceso pendiente y que la lista se quede siempre 00:34:01
Ordenada 00:34:03
Está, parece que está bien 00:34:04
Hecho, entonces vamos a parar ahora 00:34:07
Y luego ya probamos esto de ejecutar 00:34:09
Vale 00:34:11
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
3 de marzo de 2026 - 17:15
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′ 15″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
147.26 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid