Semaphore and Monitor in Java...?

Question

Hi everyone... I have a project fir my "Operating Systems". I need to write 2 program with java...

1) write a program that produce Water with 2 method Oxygen and Hydrogen. method Oxygen produce one Oxygen and method Hydrogen produce one hydrogen. when 2 Hydrogen and one Oxygen was existed H2O created. I must write this with with Semaphores and threads.

I've writed some code for this but it gives illegal monitor exeption... please help me to correct it...

This is my code:

// class for implement Thread for oxygen public class Thread_O implements Runnable {

public void run() {

    thread t = new thread();

    try {
        t.oxygen();
    } catch (InterruptedException ex) {
        Logger.getLogger(Thread_O.class.getName()).log(Level.SEVERE, null, ex);
    }
}

}

// class for implement Thread for Hydrogen public class Thread_H implements Runnable {

public void run() {

    thread t = new thread();

    try {
        t.Hydrogen();
    } catch (InterruptedException ex) {
        Logger.getLogger(Thread_H.class.getName()).log(Level.SEVERE, null, ex);
    }
}

}

//class for method Oxygen and Hydrogen public class thread {

Semaphore O = new Semaphore(0, true);
Semaphore H = new Semaphore(0, true);
Semaphore H2O = new Semaphore(0, true);
Semaphore safe = new Semaphore(1, true);

public void oxygen() throws InterruptedException {

    safe.wait();

    H.wait();
    H.wait();

    H2O.release();
    H2O.release();

    Safe.release();
    //  System.out.println("O2...!");
}

public void Hydrogen() throws InterruptedException {

    H.release();
    H2O.wait();

    //   System.out.println("H2...!");
}

}

and in action of Oxygen Button:

    Thread th = new Thread(new Thread_O());
    th.start();

and in action of Oxygen Button:

    Thread th = new Thread(new Thread_O());
    th.start();

please help me...it's emergency...

2)Write the above problem with Monitors and Sychronize.

Answer 1

You have to understand how the producer/consumer mechanism work.

Here you'll have one consumer thread and two producers.

First you'll have one thread producing oxygen, and other producing hydrogen.

Then, those molecules should be places "somewhere" ok? That "something" is the thing that has to be monitored and synchronized.

So it should go something like this:

 class Water { 
     char [] waterMolecule = new char[3]; // <-- synchronize access to this
     char hydrogen(){ 
         return 'H';
     }
     char oxygen() {
         return 'O';
     }

     void produce() {
         Thread t = new Thread( new Runnable() {
               synchronize( waterMolecule ) { 
                      waterMolecule[0] = hydrogen();
               }
          }):
          .... produce the others 


      }

      void consume() {
         synchronize watermolecule 
          if waterMolecule is complete 
              create water and clean out the molecule.
      }
  }

That's the basic idea.

Just bear in mind that you won't be able to produce another particle of oxigen until the previous one has been consumed.

Also you must always call wait in a while loop

Here's how that wait/synchronize should be coded.

Here's a number of producer/consumer samples.

Answer 2

I'm not going to decode your homework for you, but an IllegalMonitorException is thrown when you're trying to wait() on an object without being synchronized. So to wait for an object called list:

synchronized (list) {
   try {
      list.wait();
   } catch(Throwable t) {
      t.printStackTrace();
   }
}

Answer 3

Although your homework is already due, I'd like to propose CyclicBarrier as the best solution for this scenario. It allows some kind of rendezvous for the different threads (here: your molecule producers) and triggers the execution of an additional runnable on completition (here: creation of h20).