1. BENEMERITA UNIVERSIDAD
AUTONOMA DE PUEBLA
FACULTAD DE CIENCIAS
DE LA COMPUTACION
PROGRAMACION CONCURRENTE Y PARALELA
semaforos

2. LEZAMA SANCHEZ ANA LAURA
VALENCIA TOXQUI HUMBERTO
INTRODUCCION
El siguiente reporte describe los grafos con semáforos de 3,6 y 4 procesos
respectivamente, presentados el dia 10 de febrero de 2012.
DESARROLLO
1.-Grafo de 3 procesos, 3 clases, una por cada proceso, la clase
Simple_Mutex_Demo, SemaforoBinario, SemaforoGeneral, Semaphore,
SemaphoreDemo y Procesos1 donde se encuentra contenido en main.
B
A D
C
Codigo en java
Proceso1

3. class p1 extends Procesos1 implements Runnable
{
public void run()
{
try
{
SA.WAIT();
mutex.WAIT();
System.out.println("Soy el proceso #1 y la instruccion A");
Thread.sleep(5000);
//System.out.flush();
mutex.SIGNAL();
SD.SIGNAL();
} catch (InterruptedException e) {}
}
}
******************************************************
Proceso2
class p2 extends Procesos1 implements Runnable
{

4. public void run()
{
try
{
mutex.WAIT();
System.out.println("Soy el proceso #2 y la instruccion B");
Thread.sleep(5000);
//System.out.flush();
mutex.SIGNAL();
SA.SIGNAL();
SB.SIGNAL();
SC.SIGNAL();
} catch (InterruptedException e) {}
try {
SB.WAIT();
SD.WAIT();
SE.WAIT();
mutex.WAIT();
System.out.println("Soy el proceso #2 y la instruccion C");
Thread.sleep(5);
mutex.SIGNAL();
}
catch (InterruptedException e) {}
}

5. }
***************************************************************
proceso3
class p3 extends Procesos1 implements Runnable
{
public void run()
{
try
{
SC.WAIT();
mutex.WAIT();
System.out.println("Soy el proceso #3 y la instruccion D");
Thread.sleep(5000);
//System.out.flush();
mutex.SIGNAL();
SE.SIGNAL();
} catch (InterruptedException e) {}
}
}
**************************************************************
Semáforo binario
public class SemaforoBinario {

6. protected int contador = 0;
public SemaforoBinario (int valorInicial) {
contador = valorInicial;
}
synchronized public void WAIT () {
while (contador == 0)
try {
wait();
}
catch (Exception e) {}
contador--;
}
synchronized public void SIGNAL () {
contador = 1;
notify();
}
}
******************************************************
Semaphore
class Semaphore
{
private int count;
public Semaphore(int n)

7. {
this.count = n;
}
public synchronized void WAIT()
{
while(count == 0)
{
try
{
wait();
}
catch (InterruptedException e) {//keep
trying}
}
count--;
}
}
public synchronized void SIGNAL()
{
count++;
notify();
}
}
************************************************************
Procesos1

8. import java.io.*;
class Procesos1
{
protected static final SemaforoBinario SA = new SemaforoBinario(0);
protected static final SemaforoBinario SB = new SemaforoBinario(0);
protected static final SemaforoBinario SC = new SemaforoBinario(0);
protected static final SemaforoBinario SD = new SemaforoBinario(0);
protected static final SemaforoBinario SE = new SemaforoBinario(0);
protected static final SemaforoBinario mutex = new SemaforoBinario(1);
public static void main(String args[]) throws IOException
{
try
{
Thread P1 = new Thread(new p1());
Thread P2 = new Thread(new p2());
Thread P3 = new Thread(new p3());
P1.start();
P2.start();
P3.start();
Thread.sleep(300);
}
catch (InterruptedException e) {}

9. System.out.println(" Termine...");
// System.exit(0);
}
}
Salida:
♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠
2.-Grafo de 3 procesos,3 clases, una por cada proceso, la clase
Simple_Mutex_Demo, SemaforoBinario, SemaforoGeneral, Semaphore,
SemaphoreDemo y Procesos1 donde se encuentra contenido en main.
A C E
B D F
Codigo en java
Proceso1
class p1 extends Procesos1 implements Runnable
{

10. public void run()
{
try
{
// SA.WAIT();
mutex.WAIT();
System.out.println("Soy el proceso #1 y la instruccion a");
System.out.println("Soy el proceso #1 y la instruccion b");
Thread.sleep(5000);
//System.out.flush();
mutex.SIGNAL();
SA.SIGNAL();
} catch (InterruptedException e) {}
}
}
********************************************************
Proceso2
class p2 extends Procesos1 implements Runnable
{
public void run()

11. {
try
{
mutex.WAIT();
System.out.println("Soy el proceso #2 y la instruccion c");
Thread.sleep(5000);
//System.out.flush();
mutex.SIGNAL();
SC.SIGNAL();
} catch (InterruptedException e) {}
}
}
******************************************************
Proceso 3
class p3 extends Procesos1 implements Runnable
{
public void run()
{
try
{

12. mutex.WAIT();
System.out.println("Soy el proceso #3 y la instruccion e");
System.out.println("Soy el proceso #3 y la instruccion F");
Thread.sleep(5000);
//System.out.flush();
mutex.SIGNAL();
SE.SIGNAL();
} catch (InterruptedException e) {}
try
{
SA.WAIT();
SC.WAIT();
SE.WAIT();
mutex.WAIT();
System.out.println("Soy el proceso #3 y la instruccion d");
Thread.sleep(5000);
//System.out.flush();
mutex.SIGNAL();
SE.SIGNAL();
} catch (InterruptedException e) {}
}
}
******************************************************

13. Semáforo binario
public class SemaforoBinario {
protected int contador = 0;
public SemaforoBinario (int valorInicial) {
contador = valorInicial;
}
synchronized public void WAIT () {
while (contador == 0)
try {
wait();
}
catch (Exception e) {}
contador--;
}
synchronized public void SIGNAL () {
contador = 1;
notify();
}
}
******************************************************
Semaphore
class Semaphore
{

14. 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();
}
}

15. ************************************************************
Procesos1
import java.io.*;
class Procesos1
{
protected static final SemaforoBinario SA = new SemaforoBinario(0);
protected static final SemaforoBinario SB = new SemaforoBinario(0);
protected static final SemaforoBinario SC = new SemaforoBinario(0);
protected static final SemaforoBinario SD = new SemaforoBinario(0);
protected static final SemaforoBinario SE = new SemaforoBinario(0);
protected static final SemaforoBinario mutex = new SemaforoBinario(1);
public static void main(String args[]) throws IOException
{
try
{
Thread P1 = new Thread(new p1());
Thread P2 = new Thread(new p2());
Thread P3 = new Thread(new p3());
P1.start();
P2.start();
P3.start();
Thread.sleep(300);
}

16. catch (InterruptedException e) {}
System.out.println(" Termine...");
// System.exit(0);
}
}
Salida
♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠♠
3.- Grafo de 4 procesos,4 clases, una por cada proceso, la clase
Simple_Mutex_Demo, SemaforoBinario, SemaforoGeneral, Semaphore,
SemaphoreDemo y Procesos1 donde se encuentra contenido en main.
Proceso 1
class p1 extends Procesos1 implements Runnable
{
public void run()
{
try
{

17. mutex.WAIT();
System.out.println("Soy el proceso #1 y la instruccion S1");
Thread.sleep(5000);
//System.out.flush();
mutex.SIGNAL();
SA.SIGNAL();
SB.SIGNAL();
} catch (InterruptedException e) {}
}
}
***********************************************************
Proceso 2
class p2 extends Procesos1 implements Runnable
{
public void run()
{
try
{
mutex.WAIT();
SA.WAIT();
System.out.println("Soy el proceso #2 y la instruccion S2");
Thread.sleep(5000);
//System.out.flush();

18. mutex.SIGNAL();
SC.SIGNAL();
} catch (InterruptedException e) {}
}
}
************************************************************
Proceso 3
class p3 extends Procesos1 implements Runnable
{
public void run()
{
try
{
mutex.WAIT();
SB.WAIT();
System.out.println("Soy el proceso #3 y la instruccion S3");
Thread.sleep(5000);
//System.out.flush();
mutex.SIGNAL();
SD.SIGNAL();

19. } catch (InterruptedException e) {}
}
}
******************************************************
Proceso 4
class p4 extends Procesos1 implements Runnable
{
public void run()
{
try
{
mutex.WAIT();
SC.WAIT();
SD.WAIT();
System.out.println("Soy el proceso #4 y la instruccion S4");
Thread.sleep(5000);
//System.out.flush();
mutex.SIGNAL();
} catch (InterruptedException e) {}
}
}

20. **********************************************************
Semáforo binario
public class SemaforoBinario {
protected int contador = 0;
public SemaforoBinario (int valorInicial) {
contador = valorInicial;
}
synchronized public void WAIT () {
while (contador == 0)
try {
wait();
}
catch (Exception e) {}
contador--;
}
synchronized public void SIGNAL () {
contador = 1;
notify();
}
}
******************************************************
Semaphore
class Semaphore

21. {
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();
}

22. }
***************************************************************
Procesos1
import java.io.*;
class Procesos1
{
protected static final SemaforoBinario SA = new SemaforoBinario(0);
protected static final SemaforoBinario SB = new SemaforoBinario(0);
protected static final SemaforoBinario SC = new SemaforoBinario(0);
protected static final SemaforoBinario SD = new SemaforoBinario(0);
protected static final SemaforoBinario mutex = new SemaforoBinario(1);
public static void main(String args[]) throws IOException
{
try
{
Thread P1 = new Thread(new p1());
Thread P2 = new Thread(new p2());
Thread P3 = new Thread(new p3());
Thread P4 = new Thread(new p4());
P1.start();

23. P2.start();
P3.start();
P4.start();
Thread.sleep(300);
}
catch (InterruptedException e) {}
//System.out.println(" Termine...");
// System.exit(0);
}
}
Salida
******************************************************
4.-Grafo de 6 procesos 6 clases, una por cada proceso, la clase
Simple_Mutex_Demo, SemaforoBinario, SemaforoGeneral, Semaphore,
SemaphoreDemo y Procesos1 donde se encuentra contenido en main.
Proceso1
class p1 extends Procesos1 implements Runnable
{

24. public void run()
{
try
{
mutex.WAIT();
System.out.println("Soy el proceso #1 y la instruccion S1");
Thread.sleep(1000);
//System.out.flush();
mutex.SIGNAL();
SA.SIGNAL();
SB.SIGNAL();
} catch (InterruptedException e) {}
}
}
Proceso2
class p2 extends Procesos1 implements Runnable
{
public void run()
{
try
{
mutex.WAIT();
SA.WAIT();
System.out.println("Soy el proceso #2 y la
instruccion S2");

25. System.out.println("Soy el proceso #2 y la
instruccion S4");
Thread.sleep(1000);
mutex.SIGNAL();
SC.SIGNAL();
SD.SIGNAL();
} catch (InterruptedException e) {}
}
}
Proceso3
class p3 extends Procesos1 implements Runnable
{
public void run()
{
try
{
mutex.WAIT();
SB.WAIT();
System.out.println("Soy el proceso #3 y la
instruccion S3");
Thread.sleep(1000);
mutex.SIGNAL();
SE.SIGNAL();
} catch (InterruptedException e) {}
}

26. }
Proceso4
class p4 extends Procesos1 implements Runnable
{
public void run()
{
try
{
mutex.WAIT();
SC.WAIT();
System.out.println("Soy el proceso #4 y la
instruccion S5");
Thread.sleep(1000);
mutex.SIGNAL();
SF.SIGNAL();
} catch (InterruptedException e) {}
}
}
Proceso5
class p5 extends Procesos1 implements Runnable
{
public void run()
{
try
{
mutex.WAIT();

27. SD.WAIT();
SE.WAIT();
System.out.println("Soy el proceso #5 y la
instruccion S6");
Thread.sleep(1000);
mutex.SIGNAL();
SG.SIGNAL();
} catch (InterruptedException e) {}
}
}
Proceso6
class p6 extends Procesos1 implements Runnable
{
public void run()
{
try
{
mutex.WAIT();
SF.WAIT();
SG.WAIT();
System.out.println("Soy el proceso #6 y la
instruccion S7");
Thread.sleep(1000);
mutex.SIGNAL();
} catch (InterruptedException e) {}

28. }
}
*************************************************************
Semáforo binario
public class SemaforoBinario {
protected int contador = 0;
public SemaforoBinario (int valorInicial) {
contador = valorInicial;
}
synchronized public void WAIT () {
while (contador == 0)
try {
wait();
}
catch (Exception e) {}
contador--;
}
synchronized public void SIGNAL () {
contador = 1;
notify();
}
}
******************************************************

29. Semaphore
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++;

30. notify();
}
}
***********************************************************
import java.io.*;
class Procesos1
{
protected static final SemaforoBinario SA = new SemaforoBinario(0);
protected static final SemaforoBinario SB = new SemaforoBinario(0);
protected static final SemaforoBinario SC = new SemaforoBinario(0);
protected static final SemaforoBinario SD = new SemaforoBinario(0);
protected static final SemaforoBinario SE = new SemaforoBinario(0);
protected static final SemaforoBinario SF = new SemaforoBinario(0);
protected static final SemaforoBinario SG = new SemaforoBinario(0);
protected static final SemaforoBinario mutex = new SemaforoBinario(1);
public static void main(String args[]) throws IOException
{
try
{
Thread P1 = new Thread(new p1());
Thread P2 = new Thread(new p2());
Thread P3 = new Thread(new p3());
Thread P4 = new Thread(new p4());

31. Thread P5 = new Thread(new p5());
Thread P6 = new Thread(new p6());
P1.start();
P2.start();
P3.start();
P4.start();
P5.start();
P6.start();
Thread.sleep(100);
}
catch (InterruptedException e) {}
//System.out.println(" Termine...");
// System.exit(0);
}
}
***********************************************************
Salida

32. Conclusión
Los programas mencionados anteriormente me ayudaron a comprender el
concepto de semáforo y como se manejan en java.
Ubique de mejor forma los errores obtenidos en el momento de la elaboración
de los programas y pude implementar los 4 grafos ya sin problemas.
Bibliografía
http://www.cs.buap.mx/~mceron/principal_con.html