在Java中使用信号量和监视器的非法监视异常

我有一个“操作系统”项目。我需要用java编写2个程序

编写一个用氧气和氢气两种方法生产水的程序。 方法氧产生一个氧，方法氢产生一个氢。当存在2个氢和1个氧时，产生H2O。我必须用信号量和线程来写这个

将上述问题写入监视器并同步

我已经为此编写了一些代码，但它提供了非法的监视器验证。。。 请帮我改正一下

这是我的代码：

// 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...!");
    }
}

在氧气按钮的作用下：

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

---

您必须了解生产者/消费者机制是如何工作的

这里有一个消费者线程和两个生产者

首先，你会有一根线产生氧气，另一根线产生氢气

那么，这些分子应该在某处，好吗？“某物”是必须被监视和同步的东西

所以应该是这样的：

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

class-Water{
char[]waterMolecule=new char[3]；//您必须了解生产者/消费者机制是如何工作的

这里有一个消费者线程和两个生产者

首先，你会有一根线产生氧气，另一根线产生氢气

然后，这些分子应该是“某处”好吗？那“某物”就是必须被监控和同步的东西

所以应该是这样的：

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

class-Water{
char[]waterMolecule=new char[3]；//我不打算为您解码家庭作业，但当您试图在对象上执行
wait（）
而未进行
同步时，会引发非法监视异常。因此，要等待名为
list
的对象：

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

我不会为您解码家庭作业，但当您尝试对对象执行
wait（）
操作而未进行
synchronized
时，会引发非法监视器异常。因此，要等待名为
list
的对象，请执行以下操作：

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

虽然你的作业已经到期了，但我还是想提出一个解决这个问题的最佳方案。
它允许不同线程（此处：您的分子生成器）进行某种会合，并触发在完成时执行额外的可运行操作（此处：创建h20）。
虽然您的作业已经到期，但我想提出此场景的最佳解决方案。
它允许不同线程（此处：您的分子生成器）进行某种会合，并触发在完成时执行额外的可运行线程（此处：创建h20）.
你可能希望得到正确方向的有用指针，但不是有人完成了你的作业。也许你应该从查看文本开始，好像你复制并粘贴了相同的文本在底部，你遗漏了什么吗？顺便说一句，你出现异常的原因是你没有同步你的任务等待。看看这个：紧急情况是指你把自己的作业推迟到最后一分钟才完成吗？你可能期望得到正确方向的有用提示，但不是有人完成了你的作业。也许你应该从看文本开始，好像你复制并粘贴了相同的内容底部的文本，你遗漏了什么吗？顺便说一句，你出现异常的原因是你没有同步你正在等待的内容。看看这个：紧急情况是指你把自己的作业推迟到最后一分钟？