**********************************************
**********************************************
**********************************************

CENA DE LOS FILÓSOFOS

Philosopher.java

import java.util.*;

public class Philosopher implements Runnable {

        private int id;
        private DiningRoom diningRoom;

        public Philosopher(int i, DiningRoom dr) {
                id=i;
                diningRoom=dr;
        }
        public void think() {
		System.out.println(id+": thinking..");
		try { Thread.sleep(50+(int)(Math.random()*800.0)); }
		catch (Exception e) { }
	}
        public void run() {
                for (int i=0; i<3; i++) {
                        think();
                        diningRoom.dine(id);
                }
        }
	public static void main(String args[]) {
		DiningRoom dr=new DiningRoom();
		Philosopher p[]={ new Philosopher(0,dr),
			new Philosopher(1,dr), new Philosopher(2,dr),
			new Philosopher(3,dr), new Philosopher(4,dr) };
		for (int i=0; i<p.length; i++)
			new Thread(p[i]).start();
	}
}

class DiningRoom {

        private final static int THINKING=0;
        private final static int HUNGRY=1;
        private final static int EATING=2;

        private int[] state = { THINKING,THINKING,THINKING,THINKING,THINKING };

        private void eat(int p) {
		System.out.println(p+": eating..");
		try { Thread.sleep(50+(int)(Math.random()*800.0)); }
		catch (Exception e) { }
	}
        public void dine(int p) {
                grabForks(p);
                eat(p);
                releaseForks(p);
        }
        private synchronized void grabForks(int p) {
                state[p]=HUNGRY;
		System.out.println(p+": waiting & hungry..");
                test(p);
                while ( state[p] != EATING )
                  try { wait(); } catch(Exception e) {}
        }
        private synchronized void releaseForks(int p) {
                state[p]=THINKING;
                test((p+4)%5);
                test((p+1)%5);
        }
        private void test(int p) {
                if ( state[p] == HUNGRY
                     && state[(p+1)%5] != EATING
                     && state[(p+4)%5] != EATING
                ) {
                        state[p]=EATING;
                        notifyAll();
                }
        }
}

===================================================
Semaphore.java


class Semaphore extends Object
{
    private int count;

    public Semaphore(int startingCount) {
        count = startingCount;
    }

    public void down(){
        synchronized (this) {
            while (count <= 0) {
                // We must wait
                try {
                    wait();
                } catch (InterruptedException ex) {
                    // I was interupted, continue onwards
                }
            }
            // We can decrement the count
            count--;
        }
    }

    public void up(){
        synchronized (this) {
            count++;
            // notify a waiting thread to wakeup
            if (count == 1 ) {
                notify();
            }
        }
    }
}
===================================================

// Philosopher.java

import Semaphore;

public class Philosopher extends Thread {
    // Shared by all Philosophers
    public final static int N = 5;              // Number of philosophers

    public final static int THINKING = 0;       // Philosopher is thinking
    public final static int HUNGRY = 1;         // Philosopher is hungry
    public final static int EATING = 2;         // Philosopher is eating

    private static int state[] = new int[N];    // Array to keep track of everyones state

    private static Semaphore mutex = new Semaphore(1);  // Mutual exclusion for
                                                        // critical regions
    private static Semaphore s[] = new Semaphore[N];    // One for each Philosopher

    // Instance variable
    public int myNumber;                    // Which philosopher am I
    public int myLeft;                      // Number of my left neighbor
    public int myRight;                     // Number of my right neighbor

    public Philosopher(int i) {             // Make a philosopher
        myNumber = i;
        myLeft = (i+N-1) % N;               // Compute the left neighbor
        myRight = (i+1) % N;                // Compute the right neighbor
    }

    public void run() {                     // And away we go
        while(true){
            think();                        // Philosopher is thinking
            take_forks();                   // Acquire two forks or block
            eat();                          // Yum-yum, spahgetti
            put_forks();                    // Put both forks back on the table
        }
    }

    public void take_forks(){               // Take the forks I need
        mutex.down();                       // Enter critical region
        state[myNumber] = HUNGRY;           // Record the fact that I am hungry
        test(myNumber);                     // Try to acquire two forks
        mutex.up();                         // Leave critical region
        s[myNumber].down();                 // Block if forks were not acquired
    }

    public void put_forks(){
        mutex.down();                       // Enter critical region
        state[myNumber] = THINKING;         // Philosopher has finished eating
        test(myLeft);                       // See if left neighbor can now eat
        test(myRight);                      // See if right neighbor can now eat
        mutex.up();                         // Leave critical region
    }

    public void test(int k){                // Test philosopher k,
                                            // from 0 to N-1
        int onLeft = (k+N-1) % N;           // K's left neighbor
        int onRight = (k+1) % N;            // K's right neighbor
        if( state[k] == HUNGRY
            && state[onLeft] != EATING
            && state[onRight] != EATING ) {
            // Grab those forks
            state[k] = EATING;
            s[k].up();
        }
    }

    public void think(){
        System.out.println("Philosopher " + myNumber + " is thinking");
        try {
            sleep(1000);
        } catch (InterruptedException ex){ }
    }

    public void eat(){
        System.out.println("Philosopher " + myNumber + " is eating");
        try {
            sleep(5000);
        } catch (InterruptedException ex){ }
    }

    public static void main(String args[]) {

        Philosopher p[] = new Philosopher[N];

        for(int i=0; i<N; i++) {
            // Create each philosopher and their semaphore
            p[i] = new Philosopher(i);
            s[i] = new Semaphore(0);

            // Start the threads running
            p[i].start();
        }
    }
}

**********************************************
**********************************************
**********************************************

BARBERO DORMILON

public class barberia {
        
        private int nSillasEspera;
        private int nSillasEsperaOcupadas = 0;
        private boolean sillaBarberoOcupada = false;
        private boolean finCorte = false;
        private boolean barberoDormido = false;
        
        //JAVA: sólo puede haber N_Sillas_Espera_max hebras 
        //esperando dentro del monitor a que le toque.
 

          public barberia(int nSillasEspera) { 

                 this.nSillasEspera = nSillasEspera; 
         }        
 

          public synchronized boolean entrar(int clienteId)
 

              throws InterruptedException {
                 
           if (nSillasEsperaOcupadas == nSillasEspera) {
                  // Si no hay sillas libres, me voy sin cortar el pelo
                       System.out.println
                               ("---- El cliente " + clienteId + " se va sin cortarse el pelo");
                  return false; }
           else { 
                  //Me quedo esperando si la silla del barbero está
                  //ocupada
                  nSillasEsperaOcupadas ++;
                  System.out.println
                              ("---- El cliente " + clienteId + " se sienta en la silla de espera");
                  while (sillaBarberoOcupada) {wait();}
        
                  //Desocupo la silla de espera 
                  nSillasEsperaOcupadas --;
 

                  //Me siento en la silla del barbero 
                  sillaBarberoOcupada = true;
                  finCorte = false;
                  
                  //Si el barbero está dormido le despierto
                  if (barberoDormido) {
                          System.out.println
                               ("---- El cliente " + clienteId + " despierta al barbero");
                          notifyAll();}
                  
                  //Espero a que me corte el pelo
                  System.out.println
                           ("---- El cliente " + clienteId + " en la silla de barbero");
                  while (!finCorte) {wait();}
                  
                  sillaBarberoOcupada = false;
 

                  //Que pase el siguiente
                  notifyAll();
                  
                  System.out.println
                      ("---- El cliente " + clienteId + " se va con el pelo cortado");
                  return true;

           } 

          }
 

           public synchronized void esperarCliente()
 

              throws InterruptedException { 

                  //El barbero espera a que llegue un cliente
                  //Se supone que le corta el pelo fuera del 
                  //monitor
                  barberoDormido = true;
                  while(!sillaBarberoOcupada) {
                          System.out.println("++++ Barbero esperando cliente");
                          wait();
                          }
                  barberoDormido = false;               
                  System.out.println("++++ Barbero cortando el pelo");
           }
           
           public synchronized void acabarCorte(){
                  finCorte = true;
                   System.out.println("++++ Barbero termina de cortar el pelo");
                  notifyAll();
           }
 

}



**********************************************
**********************************************
**********************************************

CubbyHole para procuder.java, consumer.java, producerconsumertest.java

class CubbyHole {
    private int contents;
    private boolean available = false;

    public synchronized int get() {
        while (available == false) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        available = false;
        notify();
        return contents;
    }

    public synchronized void put(int value) {
        while (available == true) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        contents = value;
        available = true;
        notify();
    }
}

**********************************************
**********************************************
**********************************************