IllegalMonitorException using Semaphore and Monitor in Java

I have a project for my "Operating Systems". I need to write 2 programs 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.

2. Write the above problem with Monitors and Sychronize.

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 logger = Logger.getLogger(Thread_O.class.getName());
            logger.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 开发者_开发百科logger = Logger.getLogger(Thread_H.class.getName());
            logger.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();

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

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.

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).