1. Obtener las sentencias cobegin/end del grafo de precedencia

1.
Obtener las sentencias cobegin/end del grafo
de precedencia siguiente utilizando semáforos.
(ejemplo anterior)
2. Realizar el programa en Java que permita enviar
los mensajes de cada proceso según entren a la
sección critica mandando el mensaje soy el
proceso #1 y la instrucción s# utilizando
semáforos. (crear el semáforo)
BEGIN
S1
COBEGIN
BEGIN
S1;
Signal(a);
Signal(b);
END
S2
BEGIN
Wait(a);
S2;
END
S3
BEGIN
Wait(b);
S3;
Signal(e);
END
S4
BEGIN
S4;
Signal(c);
Signal(d);
END
S5
BEGIN
Wait(5);
S5;
Signal(f);
END
S6
BEGIN
Wait(d);
S6;
Signal(g);
END
S7
BEGIN
Wait(f);
Wait(g);
S7;
END
COEND
END
public class Semaphore
{
private int count;
public Semaphore(int n) {
this.count = n; }
public synchronized void WAIT()
{
while(count == 0) {
try
{
wait();
}
catch (InterruptedException e) {//keep trying}
}
count--;
}
}
public synchronized void SIGNAL()
{
count++;
notify();
}
}
public class p1 extends Thread{
static Semaphore a,b;
public p1(Semaphore a, Semaphore b) {
this.a = a;
this.b = b;
}
public void run(){
System.out.println("Soy el proceso #1 y la instruccion S1");
a.SIGNAL();
b.SIGNAL();
}
}
public class p2 extends Thread{
static Semaphore a;
public p2(Semaphore a) {
this.a = a;
}
public void run(){
a.WAIT();
System.out.println("Soy el proceso #2 y la instruccion S2");
}
}
public class p3 extends Thread{
static Semaphore e,b;
public p3(Semaphore b, Semaphore e) {
this.b = b;
this.e = e;
}
public void run(){
b.WAIT();
System.out.println("Soy el proceso #3 y la instruccion S3");
e.SIGNAL();
}
}
public class p4 extends Thread{
static Semaphore c,d;
public p4(Semaphore c, Semaphore d) {
this.c = c;
this.d = d;
}
public void run(){
System.out.println("Soy el proceso #4 y la instruccion S4");
c.SIGNAL();
d.SIGNAL();
}
}
public class p5 extends Thread{
static Semaphore c,f;
public p5(Semaphore c, Semaphore f) {
this.c = c;
this.f = f;
}
public void run(){
c.WAIT();
System.out.println("Soy el proceso #5 y la instruccion S5");
f.SIGNAL();
}
}
public class p6 extends Thread{
static Semaphore d,e,g;
public p6(Semaphore d, Semaphore e, Semaphore g) {
this.d = d;
this.e = e;
this.g = g;
}
public void run(){
d.WAIT();
e.WAIT();
System.out.println("Soy el proceso #6 y la instruccion S6");
g.SIGNAL();
}
}
public class p7 extends Thread{
static Semaphore f,g;
public p7(Semaphore f, Semaphore g) {
this.f = f;
this.g = g;
}
public void run(){
f.WAIT();
g.WAIT();
System.out.println("Soy el proceso #7 y la instruccion S7");
}
}
public class Procesos{
public Procesos() {
}
public static void main (String[] args) {
Semaphore a=new Semaphore(1);
Semaphore b=new Semaphore(1);
Semaphore c=new Semaphore(0);
Semaphore d=new Semaphore(0);
Semaphore e=new Semaphore(0);
Semaphore f=new Semaphore(0);
Semaphore g=new Semaphore(0);
p1 proceso1=new p1(a,b);
p2 proceso2=new p2(a);
p3 proceso3=new p3(b,e);
p4 proceso4=new p4(c,d);
p5 proceso5=new p5(c,f);
p6 proceso6=new p6(d,e,g);
p7 proceso7=new p7(f,g);
proceso1.start();
proceso2.start();
proceso3.start();
proceso4.start();
proceso5.start();
proceso6.start();
proceso7.start();
}
}