1. Problema: el puente estrecho. Disponemos de dos caminos que separan dos sentidos de circulación: Norte y Sur. Ambos caminos convergen en uno solo cuando se trata de cruzar un río. Existen coches que quieren pasar de norte a sur y de sur a norte. En cualquier momento, solo pueden atravesar el puente uno o mas coches que vayan en el mismo sentido( no se mezclan coches que van en sentido opuesto).
import java.lang.Object;
import java.lang.Thread;
import java.io.*;
class PuenteEstrecho{
bolean used;
PuenteEstrecho(){
used = false;
}
public synchronized void pasar (String sentido){
System.out.println(“+Un carro en sentido” +sentido+ ”esta pasando.”);
try{
Thread.sleep(1000);
} catch(InterruptedException e){}
System.out.println(“**El carro en sentido”+sentido+ “ ya pason”);
}
}
class Carros extendí Thread{
String sentido;
PuenteEstrecho rec;
Carros(String l, PuenteEstrecho p){
sentido = l;
rec = p;
}
public void run(){
int i=0;
while(i<0){
/*while(re.used ==true){
try{
wait()
} catch(InterruptedException e){}
}*/
rec.pasar(sentido);
i++;
}
}
}
class Test{
public static void main(String args[]){
PuenteEstrecho p=new PuenteEstrecho;
Carros Norte=new Carros(“Norte”,p);
Carros Sur=new Carros(“Sur”,p);
Norte.start();
Sur.start();
try{
Norte.join();
Sur.join();
}catch(InterruptedException e){}
}
}
2. Explique como funciona un semáforo y cuales son sus operaciones
Un semáforo es una variable S entera que toma valores no negativos, y sobre la cual aparecen definidas dos operaciones:
1. Wait(S)_ Si S > 0 entonces S := S − 1. En caso contrario, se suspende la ejecución del proceso y éste queda bloqueado en el semáforo S.
2. Signal(S)_ Si hay algún proceso que ha sido suspendido en el semáforo, se le despierta y puede continuar su ejecución. En caso contrario, S := S+1.
3. Como se declara un semáforo con primitivas en java
- Syncronized(), wait(), notify(), run() y Start()
- Semáforos para resolver el problema del búfer finito
Mutex : Semaphore ( Initial_Value => 1 );
Huecos : Semaphore (N);
Llenos : Semaphore (0);
4. Que problemas de concurrencia resuelve un semáforo
Exclusión mutua, sincronización y sección critica
5. Diferencia entre monitor y semáforo
- Los monitores no son más potentes ni útiles que los semáforos, pero sí más estructurados y legibles
- El monitor presenta un mayor nivel de abstracción que el semáforo
6. Cuales son las características de los monitores
1. Centralización de recursos. Los monitores centralizan una serie de recursos, garantizando que el acceso a ellos tiene lugar bajo exclusión mutua.
2. Estructuración de los datos. Los monitores protegen un conjunto de datos críticos comunes a varios procesos. El monitor puede verse como (y de hecho su implementación es muy parecida a) un TDA.
3. Elevación del nivel de abstracción. Los programadores de procesos que comparten recursos no han de preocuparse de proteger la exclusión mutua de sus regiones críticas. Basta con llamar al monitor que maneja esos recursos. Será este quien asegure la exclusión mutua.
7. Como se implementa un monitor
1. Wait(C): El proceso que llamó a el procedimiento del monitor que contiene esta sentencia es suspendido en una cola FIFO asociada a C. La exclusión mutua sobre el monitor es liberada, de forma que otros procesos puedan entrar en el monitor (y quizás señalizar la condición C).
2. Send(C): Se despierta al proceso situado en la cabeza de la cola si hay alguno. Si no lo hay, la operación es simplemente ignorada.
3. Awaited(C): Devuelve true si la cola de C es no vacía. En el monitor productor-consumidor se utilizaron dos señales:
1. Not_Empty: que suspende al consumidor hasta que el buffer esté no vacio”, y contenga por tanto elementos para ser consumidos.
2. Not_Full: que suspende al productor hasta que el buffer esté ”no lleno”, y se disponga de huecos para insertar elementos.
