Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Mejoras de tiempos de desplazamiento

2011-06-07T17:48:39Z

Lcarlosp:

;1. FCFS (por orden de llegada "FIFO"): Las peticiones se atienden en el mismo orden en que se reciben.

;2. SSTF (por menor tiempo de búsqueda): Ordeno todo y cojo el lote de ''n'' solicitudes de pista. Si no se llega a las ''n'' peticiones tras un tiempo se pasa a la busqueda. Aplaza las peticiones lejanas indefinidamente cuando ''n'' tiende a ifinito (''n'' -> ∞).

;3. N-SCAN (criterio del ascensor): Dentro de cada lote de la lista de accesos, escogemos aquellos sectores que nos permita ascender y descender en la tabla, dando de esta manera prioridad a los sectores que se encuentren en la parte central de la pista.

|
| /\ | /\
| / \ | / \
| / \ | / \
___|/______\|/______\__
|
Nota: La gráfica resultante no tiene por qué ser simétrica, dependerá de los sectores a los que accedamos.

Nota2: El número de sectores integrantes de cada lote será el indicado por la N, ejemplo: 3-SCAN, 4-SCAN, etc.

;4. C-SCAN (Circular-Scan): Da preferencia al ascenso o descenso, y se mantiene. Así se elimina el trato favorable a las partes centrales.

| |
| /| /| /| |\ |\ |\ |
| / | / | / | ó | \ | \ | \ |
| / | / | / | | \ | \ | \ |
___|/___|/___|_/___|_ ___|___\|__ \|___\|_
| |

Algún alma caritativa sube los ejemplos de clase antes del parcial??

Otro ejemplo

2011-06-07T16:25:39Z

Lcarlosp:

Ej: tenemos los siguientes procesos: m(P1)=6KB,m(P2)=1KB,m(P3)=3KB,m(P4)=31KB,m(P5)=30KB,m(P6)=2KB,m(P7)=4KB,m(P8)=1KB;
y una memoria de 64 KB divididos en 4 huecos como sigue:
_____
|_____| H1 = 8KB | m(P1)=6KB | H0(P1)=0 | t(P1)=8
|_____| H2 = 8KB | m(P2)=1KB | H0(P2)=0 | t(P2)=8
| | | m(P3)=3KB | H0(P3)=1 | t(P3)=2
|_____| H3 = 16KB | m(P4)=31KB | H0(P4)=0 | t(P4)=2
| | | m(P5)=30KB | H0(P5)=0 | t(P5)=2
| | | m(P6)=2KB | H0(P6)=0 | t(P6)=2
| | H4 = 32KB | m(P7)=4KB | H0(P7)=2 | t(P7)=2
|_____| | m(P8)=1KB | H0(P8)=0 | t(P8)=2

solución:
>: fin del proceso.

| P1| P1| P1| P1| P1| P1| P1| P1| |
H1|---|---|---|---|---|---|---|---> |
| | | | | | | | | |
| P6| P6| P7| P7| P3| P3| | | |
H2|---|--->---|--->---|---> | | |
| | | | | | | | | |
| P2| P2| P2| P2| P2| P2| P2| P2| |
H3|---|---|---|---|---|---|---|---> |
| | | | | | | | | |
| P4| P4| P5| P5| P8| P8| | | |
H4|---|--->---|--->---|---> | | |
|___|___|___|___|___|___|___|___|___|__>
0 1 2 3 4 5 6 7 8 9 t

¿A qué criterio pertenece esta solución?
--[[Usuario:Jorcalmar|Jorcalmar]] 16:42 31 may 2011 (UTC)

Soluciones:

'''a) Mejor ajuste estático''': Asociamos a cada proceso la partición menor en la que cabe. En nuestro caso:
P1: H1
P2: H2
P3: H1/H2 el que acabe primero.
P4: H4
P5: H4
P6: H1/H2 el que acabe primero.
P7: H1/H2 el que acabe primero.
P8: H1/H2 el que acabe primero.

Como vemos, usando este criterio, la partición H3 se queda siempre libre. Éste es uno de los inconvenientes del mejor ajuste estático, no aprovechamos todas las particiones.

| P1| P1| P1| P1| P1| P1| P1| P1| P3| P3| P7| P7
H1|---|---|---|---|---|---|---|--->---|--->---|--->
| | | | | | | | | | | | |
| P2| P2| P2| P2| P2| P2| P2| P2| P6| P6| P8| P8
H2|---|---|---|---|---|---|---|--->---|-->|---|--->
| | | | | | | | | | | | |
| | | | | | | | | | | | |
H3| | | | | | | | | | | | |
| | | | | | | | | | | | |
| P4| P4| P5| P5| | | | | | | | |
H4|---|--->---|---> | | | | | | | |
|___|___|___|___|___|___|___|___|___|__ |___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12

'''b) Primer ajuste:''' En este criterio, elegimos el primer proceso que quepa en la partición que tengamos en la cola de procesos en espera.
Para este criterio, es conveniente verificar en cada instante de tiempo qué procesos tengo en espera (y en qué orden) y qué particiones se me van quedando libres en cada instante.

| P1| P1| P1| P1| P1| P1| P1| P1| | | | |
H1|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P2| P2| P2| P2| P2| P2| P2| P2| | | | |
H2|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P6| P6| P8| P8| P3| P3| | | | | | |
H3|---|--->---|--->---|---> | | | | | |
| | | | | | | | | | | | |
| P4| P4| P5| P5| P7| P7| | | | | | |
H4|---|--->---|--->---|---> | | | | | |
|___|___|___|___|___|___|___|___|___|__ |___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12

'''DUDAAAAAAA!!''' Porque se pone P8 antes que P3?? No esta P3 antes en la cola???

Mi solucion sería igual pero cambiando:
H3: P6-P3-P7
H4: P4-P5-P8

Alguien la resuelve?? --[[Usuario:Lcarlosp|Lcarlosp]] 16:25 7 jun 2011 (UTC)

'''c) Mejor ajuste dinámico:'''En este criterio, hemos de seleccionar el mayor proceso que quepa en nuestra partición. Para esto debemos recorrer toda la cola de procesos en espera. Como inconveniente nos encontramos con que los procesos menores quedarán aplazados en favor de los procesos de mayor tamaño. Una vez más debemos tener cuidado verificando el estado de la cola de espera en cada instante de tiempo para la elección de los procesos.

| P1| P1| P1| P1| P1| P1| P1| P1| | | | |
H1|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P6| P6| P7| P7| P3| P3| | | | | | |
H2|---|--->---|--->---|---> | | | | | |
| | | | | | | | | | | | |
| P2| P2| P2| P2| P2| P2| P2| P2| | | | |
H3|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P4| P4| P5| P5| P8| P8| | | | | | |
H4|---|--->---|--->---|---> | | | | | |
|___|___|___|___|___|___|___|___|___|__ |___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12

Como podemos observar, el proceso 8, queda aplazado hasta que el resto de procesos mayores han terminado. Para solucionar este problema tenemos el siguiente criterio, mayor que quepa con aplazamiento, en el cual hacemos uso de una variable 'umbral' que selecciona aquellos procesos que han sido aplazados un número dado de veces.--[[Usuario:Jorcalmar|Jorcalmar]] 17:43 31 may 2011 (UTC)

--El c en realidad,¿no seria?:

| P1| P1| P1| P1| P1| P1| P1| P1| | | | |
H1|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P7| P7| P6| P6| P8| P8| | | | | | |
H2|---|--->---|--->---|---> | | | | | |
| | | | | | | | | | | | |
| P3| P3| P2| P2| P2| P2| P2| P2| P2| P2| | |
H3|---|--->---|---|---|---|---|---|---|---> | |
| | | | | | | | | | | | |
| P4| P4| P5| P5| | | | | | | | |
H4|---|--->---|---> | | | | | | | |
|___|___|___|___|___|___|___|___|___|__ |___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12

Cambia las asignaciones de H2 ya que P7>P3>P6 y por ese mismo criterio, en H3 primero entraria P3 y P8 entraria en H2.--[[Usuario:Luidela1|Luidela1]] 14:26 7 jun 2011 (UTC)

Creo que sería como dices Jorcalmar, pero cambiando para que primero entren en H2 P6-P7-P8, recuerda que Ho(P7)=2.--[[Usuario:alvrodber|alvrodber]] 17:25 7 jun 2011 (UTC)

Sol reloj

2011-06-06T12:26:28Z

Lcarlosp:

_________________accesos a página____________________
|_2_|_2_|_3_|_1_|_1_|_3_|_4_|_5_|_1_|_1_|_2_|_3_|_4_|
========================================================
1 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 5 | 5 | 5 | 5 | 5 | 5 |
| | | | | | | | | | | | | |
m---|---|---|---|---|---|---|---|---|---|---|---|---|---|
a 2 | | | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 2 | 2 | 2 |
r | | | | | | | | | | | | | |
c---|---|---|---|---|---|---|---|---|---|---|---|---|---|
o 3 | | | | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 4 |
s | | | | | | | | | | | | | |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
4 | | | | | | | 4 | 4 | 4 | 4 | 4 | 3 | 3 |
| | | | | | | | | | | | | |
------------------------------------------------------------> t

7
tasa fallos pág = ---- = 0,615
13

Creo que la tasa es de 8/13, que coincidiría con el criterio de segunda oportunidad. --[[Usuario:Lcarlosp|Lcarlosp]] 12:26 6 jun 2011 (UTC)

[[Criterios_de_reemplazo|Volver]]

Sol 6

2011-06-06T11:54:58Z

Lcarlosp:

La lista de paginas a la que se acceden son las siguientes :
''' 2(R)--2(W)--3(R)--1(R)--1(W)--3(R)--4(W)--5(R)--1(R)--1(W)--2(R)--3(W)--4(R)'''

El bit R se pone a 0 cada 4 accesos
___1__ __ 2__ __3___ __4___
1º Acceso | | | | |
Acceso a: | 2 | | | | Nª de fallos: 1
Pagina 2 |R=1M=0|R=0M=0|R=0M=0|R=0M=0|
|______|______|______|______|
2º Acceso | | | | |
Acceso a: | 2 | | | | Nª de fallos: 1
Pagina 2 |R=1M=1|R=0M=0|R=0M=0|R=0M=0|
|______|______|______|______|
3º Acceso | | | | |
Acceso a: | 2 | 3 | | | Nª de fallos: 2
Pagina 3 |R=1M=1|R=1M=0|R=0M=0|R=0M=0|
|______|______|______|______|
4º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | | Nª de fallos: 3
Pagina 1 |R=1M=1|R=1M=0|R=1M=0|R=0M=0|
|______|______|______|______|<------------------- EL BIT R SE PONE A 0
5º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | | Nª de fallos: 3
Pagina 1 |R=0M=1|R=0M=0|R=1M=1|R=0M=0|
|______|______|______|______|
6º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | | Nª de fallos: 3
Pagina 3 |R=0M=1|R=1M=0|R=1M=1|R=0M=0|
|______|______|______|______|
7º Acceso | | | | |
Acceso a: | 2 | 3 | 1 | 4 | Nª de fallos: 4
Pagina 4 |R=0M=1|R=1M=0|R=1M=1|R=1M=1|
|______|______|______|______|
8º Acceso | | | | |
Acceso a: | 5 | 3 | 1 | 4 | Nª de fallos: 5
Pagina 5 |R=1M=0|R=1M=0|R=1M=1|R=1M=1|
|______|______|______|______|<------------------- EL BIT R SE PONE A 0
9º Acceso | | | | |
Acceso a: | 5 | 3 | 1 | 4 | Nª de fallos: 5
Pagina 1 |R=0M=0|R=0M=0|R=1M=1|R=0M=1|
|______|______|______|______|
10º Acceso | | | | |
Acceso a: | 5 | 3 | 1 | 4 | Nª de fallos: 6
Pagina 1 |R=0M=0|R=0M=0|R=1M=1|R=0M=1|
|______|______|______|______|
11º Acceso | | | | |
Acceso a: | 5 | 2 | 1 | 4 | Nª de fallos: 7
Pagina 2 |R=0M=0|R=1M=0|R=1M=1|R=0M=1|
|______|______|______|______|
12º Acceso | | | | |
Acceso a: | 3 | 2 | 1 | 4 | Nª de fallos: 8
Pagina 3 |R=1M=1|R=1M=0|R=1M=1|R=0M=1|
|______|______|______|______|<------------------- EL BIT R SE PONE A 0
13º Acceso | | | | |
Acceso a: | 3 | 2 | 1 | 4 | Nª de fallos: 8
Pagina 4 |R=0M=1|R=0M=0|R=0M=1|R=1M=1|
|______|______|______|______|

--[[Usuario:Fcoramlop|Fcoramlop]] 22:17 4 jun 2011 (UTC)
8
tasa fallos pág = ---- = 0,615
13

[[Criterios_de_reemplazo|Volver]]

El acceso 10 no debería de ser fallo, no?
Y el acceso 11 podria elegir el marco 1 y quitar la pagina 5?? Es que de esa forma también bajaría la tasa de fallos a 6/13... Con los bits R y M no sabes que la página 5 llego despues de la 3...
Alguien responde?? --[[Usuario:Lcarlosp|Lcarlosp]] 11:54 6 jun 2011 (UTC)

Sol 10

2011-06-06T11:32:55Z

Lcarlosp: /* Sustitución por envejecimiento */

==Sustitución por envejecimiento==
Periodo de 4, registro R de 3 bits.
_________________accesos a página_______________________
|_2_|_2_|_3_|_1_||_1_|_3_|_4_|_5_||_1_|_1_|_2_|_3_||_4_|
===========================================================
1 | 2 | = | = | = || 2 | = | = | 5 || 5 | = | = | = || 4 |
|100| = | = | = ||010| = | = |100||010| = | = | = ||100|
m---|---|---|---|---||---|---|---|---||---|---|---|---||---|
a 2 | | | 3 | = || 3 | 3 | = | = || 3 | = | = | 3 || 3 |
r | | |100| = ||010|110| = | = ||011| = | = |111||011|
c---|---|---|---|---||---|---|---|---||---|---|---|---||---|
o 3 | | | | 1 || 1 | = | = | = || 1 | = | = | = || 1 |
s | | | |100||110| = | = | = ||111| = | = | = ||011|
---|---|---|---|---||---|---|---|---||---|---|---|---||---|
4 | | | | || | | 4 | = || 4 | = | 2 | = || 2 |
| | | | || | |100| = ||010| = |100| = ||010|
------------------------------------------------------------> t

7
tasa fallos pág = ---- = 0,615
13

Una pregunta: En el acceso número 11 podriamos elegir el marco 1 que contiene al 5 si queremos, no? Es que entonces la tasa de error será menor. 6/13. ¿ES POSIBLE?

--[[Usuario:Lcarlosp|Lcarlosp]] 11:32 6 jun 2011 (UTC)

[[Criterios_de_reemplazo|Volver]]

Sol 6

2011-06-06T07:53:55Z

Lcarlosp:

Sol 5

2011-06-04T10:45:57Z

Lcarlosp:

7
tasa fallos pág = ---- = 0,538
13

'''2--2--3--1--1--3--4--5--1--1--2--3--4'''

2--2--3--1--1--1--4--5--5--5--2--3--4

X--X--2--3--3--3--1--4--4--4--5--2--3

X--X--X--2--2--2--3--1--1--1--4--5--2

F--A--F--F--A--A--F--F--A--A--F--F--F

LA TASA DE FALLOS ME SALE 8/13=0'61

Sol 3

2011-06-04T10:41:16Z

Lcarlosp:

Solución:
6/13 = 0'4615
--[[Usuario:Jorcalmar|Jorcalmar]] 16:52 2 jun 2011 (UTC)

'''2--2--3--1--1--3--4--5--1--1--2--3--4'''

2--2--3--1--1--3--4--5--1--1--2--3--4

X--X--2--3--3--1--1--1--4--4--1--1--3

X--X--X--2--2--2--2--2--2--2--4--4--1

F--A--F--F--A--A--F--F--F--A--A--F--A

MI TASA DE FALLOS ES 7/13=0'53

Usuario: lcarlosp (jejeje, que no se como se pone el enlace)

Sol 1

2011-06-04T10:35:50Z

Lcarlosp:

6
tasa fallos pág = ---- = 0,46
13

'''2--2--3--1--1--3--4--5--1--1--2--3--4'''

2--2--3--1--1--1--4--5--5--5--5--3--4

X--X--2--3--3--3--1--1--1--1--1--5--3

X--X--X--2--2--2--2--2--2--2--2--1--5

F--A--F--F--A--A--F--F--A--A--A--F--F

MI TASA DE FALLOS ME SALE 7/13= 0'53

Sol 2

2011-06-04T10:32:55Z

Lcarlosp:

9
tasa fallos pág = ---- = 0,69
13

'''2--2--3--1--1--3--4--5--1--1--2--3--4'''

2--2--3--1--1--1--4--5--1--1--2--3--4

X--X--2--3--3--3--3--4--5--5--1--2--3

X--X--X--2--2--2--2--3--4--4--5--1--2

F--A--F--F--A--A--F--F--F--A--F--F--F

Sol 1

2011-06-04T10:27:26Z

Lcarlosp:

Cerrojos

2011-05-10T10:33:51Z

Lcarlosp: /* Ejemplo de implementación */

= Ejemplo de implementación =

El siguiente código sería un posible ejemplo del uso de control de concurrencia mediante cerrojos:

<source lang="c">
int cerrojo = 1; /* Inicializamos la variable cerrojo. Esto sería sólo válido para
hilos, ya que los procesos no comparten espacio de memoria */

while(cerrojo == 0); // Protocolo de
cerrojo = 0; // entrada

... // Sección crítica

cerrojo = 1; // Protocolo de salida
</source>

Sin embargo, esto es problemático: Supongamos que tenemos únicamente un proceso con dos hilos (Hx y Hy) y el planificador retire al hilo Hx justo antes de ejecutarse la instrucción ''cerrojo = 0;''. El hilo Hy ejecuta su código, entra en la sección crítica (Esto puede ocurrir ya que cerrojo sigue a 1) y el planificador le retira el uso del procesador dentro de ésta. A continuación, se le vuelve a asignar el procesador a Hx.

De esta forma, tenemos a dos hilos ejecutando código de la sección crítica. Para evitar este problema, debemos implementar los protocolos de entrada y salida de forma que se ejecuten en una sola instrucción, con lo cual o el planificador retira el uso del procesador antes de esta instrucción, o sino lo retira después de haberla ejecutado.

= Cerrojos mediante instrucciones atómicas =

Podemos implementar cerrojos mediante instrucciones especiales de comprobación y puesta a 0 y 1.

<source lang="c">
int cerrojo = 0;

void lock() {
while (__sync_lock_test_and_set(&cerrojo, 1));
}

void unlock() {
__sync_lock_release(&cerrojo);
}
</source>

El método lock comprueba mediante __sync_locktest_and_set(&cerrojo,1) el valor del cerrojo: si es 0, cambia el valor del cerrojo a 1 y devuelve 0, por tanto, se sale del while y entra en sección crítica; si es 1, devuelve 1 y continúa comprobando el valor, por tanto, no entra en situación crítica hasta que cambie el valor del cerrojo.

El método unlock, mediante _sync_lock_release(&cerrojo), cambia el valor del cerrojo a 0.

* http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Atomic-Builtins.html
* http://stackoverflow.com/questions/1383363/is-my-spin-lock-implementation-correct-and-optimal

Cerrojos

2011-05-10T10:31:52Z

Lcarlosp: /* Ejemplo de implementación */

= Ejemplo de implementación =

El siguiente código sería un posible ejemplo del uso de control de concurrencia mediante cerrojos:

<source lang="c">
int cerrojo = 1; /* Inicializamos la variable cerrojo. Esto sería sólo válido para
hilos, ya que los procesos no comparten espacio de memoria */

while(cerrojo == 0); // Protocolo de ¿Pablo, no sería while (cerrojo != 0)?
cerrojo = 0; // entrada

... // Sección crítica

cerrojo = 1; // Protocolo de salida
</source>

Sin embargo, esto es problemático: Supongamos que tenemos únicamente un proceso con dos hilos (Hx y Hy) y el planificador retire al hilo Hx justo antes de ejecutarse la instrucción ''cerrojo = 0;''. El hilo Hy ejecuta su código, entra en la sección crítica (Esto puede ocurrir ya que cerrojo sigue a 1) y el planificador le retira el uso del procesador dentro de ésta. A continuación, se le vuelve a asignar el procesador a Hx.

De esta forma, tenemos a dos hilos ejecutando código de la sección crítica. Para evitar este problema, debemos implementar los protocolos de entrada y salida de forma que se ejecuten en una sola instrucción, con lo cual o el planificador retira el uso del procesador antes de esta instrucción, o sino lo retira después de haberla ejecutado.

= Cerrojos mediante instrucciones atómicas =

Podemos implementar cerrojos mediante instrucciones especiales de comprobación y puesta a 0 y 1.

<source lang="c">
int cerrojo = 0;

void lock() {
while (__sync_lock_test_and_set(&cerrojo, 1));
}

void unlock() {
__sync_lock_release(&cerrojo);
}
</source>

El método lock comprueba mediante __sync_locktest_and_set(&cerrojo,1) el valor del cerrojo: si es 0, cambia el valor del cerrojo a 1 y devuelve 0, por tanto, se sale del while y entra en sección crítica; si es 1, devuelve 1 y continúa comprobando el valor, por tanto, no entra en situación crítica hasta que cambie el valor del cerrojo.

El método unlock, mediante _sync_lock_release(&cerrojo), cambia el valor del cerrojo a 0.

* http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Atomic-Builtins.html
* http://stackoverflow.com/questions/1383363/is-my-spin-lock-implementation-correct-and-optimal

Solución ejercicio 3

2011-05-09T16:01:20Z

Lcarlosp:

La solución no es correcta, ya que se bloquearía el proceso que ejecuta el while del productor y también el del consumidor, y no se avanzaría en la ejecución.
Sería correcto si el semáforo del productor se inicializara a 1.

También habría que asegurar que el proceso P1 comenzará antes que P2, no??
Por lo que seguro que funcionaria con el contador de P1 igual a 1, y contador de P2 igual a 0, no??

Solución ejercicio 3

2011-05-09T15:59:54Z

Lcarlosp:

Solución de los ejercicios de concurrencia

2011-05-09T14:59:23Z

Lcarlosp:

| #1| #2| #3| | | | #4| #1| #2| | | | #3| #4|#1-El programa ya termina
H1 |---|---|---| | | |---|---|---| | | |---|---|---| | | | | |
| | | | | | | | | | | | | | | | | | | | |
| | | | #1| #2| #2| | | | #2| #2| #2| | | | #2| #3| #4| #1| #2| #3| #4| El programa termina.
H2 | | | |---|---|---| | | |---|---|---| | | |---|---|---|---| |
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

En este ejercicio, el hilo 2 se queda esperando continuamente a que el hilo 1 libere el cerrojo para poder acceder a la función.
El programa finaliza en el hilo 1 cuando llega dos veces a la instrucción 4 (bucle for).

Modificación:

Solución:

| #1| #2| #3| | | | #4| #1| #2| | | | #3| #4| > | | | | | | | |
H1 |---|---|---| | | |---|---|---| | | |---|---|---| | | | | | | |
| | | | | | | | | | | | | | | | | | | | | | |
| | | | #1| __| __| | | | __| __| __| | | | #2| #3| #4| #1| #2| #3| #4|
H2 | | | |---|---|---| | | |---|---|---| | | |---|---|---|---|---|---|---|
| | | | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

Posible solución:

Los hilos comparten variables por lo que la variable i está siendo compartida por ambos hilos. Además, al ser los cerrojos un control de concurrencia de espera activa, tiene que comprobar continuamente la condición que me permite acceder a la sección crítica. En un bucle for, el incremento se hace una vez realizada la iteración, por lo que tendrá que comprobar en la instrucción 1 si el contador cumple la condición o no. Dicho esto y si no me equivoco la solución sería la siguiente:

| #1| #2| #3| | | | #4| #1| #2| | | | #3| #4| #1| | | | | |
H1 |---|---|---| | | |---|---|---| | | |---|---|---| | | | | |
| | | | | | | | | | | | | | | | | | | | |
| | | | #1| #2| #2| | | | #2| #2| #2| | | | #2| #3| #4| #1| |
H2 | | | |---|---|---| | | |---|---|---| | | |---|---|---|---| |
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Posible solución2: Lo que explicas esta muy bien, pero creo que la condición que expones en tu apartado es i=<2, cuando el ejercicio pide i<2. Por lo que habria que cortar un trozo, ¿no?

| #1| #2| #3| | | | #4| #1| #1| | | | | | | | | | | |
H1 |---|---|---| | | |---|---|---| | | |---|---|---| | | | | |
| | | | | | | | | | | | | | | | | | | | |
| | | | #1| #2| #2| | | | #2| #3| #4| | | | | | | | |
H2 | | | |---|---|---| | | |---|---|---| | | |---|---|---|---| |
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20