Java 如何用信号量替换synchronized、wait、notify？（生产者和消费者）

晚上好,

我想知道如何用信号量替换下面代码中的synchronized、wait和notify？我必须在哪里创建信号量变量

   import java.util.*;

   class Producer
   extends Thread
   {
     private Vector v;

     public Producer(Vector v)
     {
       this.v = v;
     }

     public void run()
     {
       String s;

       while (true) {
         synchronized (v) {
           s = "Value"+Math.random();
           v.addElement(s);
           System.out.println("Producer created "+s);
           v.notify();
         }
         try {
           Thread.sleep((int)(100*Math.random()));
         } catch (InterruptedException e) {
           //nothing
         }
       }
     }
   }

   class Consumer
   extends Thread
   {
      private Vector v;

      public Consumer(Vector v)
      {
         this.v = v;
      }

      public void run()
      {
         while (true) {
            synchronized (v) {
               if (v.size() < 1) {
                  try {
                     v.wait();
                  } catch (InterruptedException e) {
                     //nothing
                  }
               }
               System.out.print(
                 " Consumer found "+(String)v.elementAt(0)
               );
               v.removeElementAt(0);
               System.out.println(" (remaning: "+v.size()+")");
            }
            try {
               Thread.sleep((int)(100*Math.random()));
            } catch (InterruptedException e) {
               //nothing
            }
         }
      }
   }

import java.util.*；
阶级制作人
延长线程
{
私有向量v；
公共制作人（向量v）
{
这个，v=v；
}
公开募捐
{
字符串s；
while（true）{
同步（v）{
s=“Value”+Math.random（）；
v、 增编；
System.out.println（“制作人创建的”+s）；
v、 通知（）；
}
试一试{
sleep（（int）（100*Math.random（））；
}捕捉（中断异常e）{
//没什么
}
}
}
}
阶级消费者
延长线程
{
私有向量v；
公共消费者（向量v）
{
这个，v=v；
}
公开募捐
{
while（true）{
同步（v）{
如果（v.size（）<1）{
试一试{
v、 等待（）；
}捕捉（中断异常e）{
//没什么
}
}
系统输出(
“消费者发现”+（字符串）v.elementAt（0）
);
v、 removeElementAt（0）；
System.out.println（“（（发回：+v.size（）+”）”）；
}
试一试{
sleep（（int）（100*Math.random（））；
}捕捉（中断异常e）{
//没什么
}
}
}
}

如果有人能帮我，我会很高兴的

---

提前感谢您。

将信号量视为一个锁，可以允许多个线程访问共享资源。无论您将信号量初始化为多少，都将允许那么多线程同时访问资源。在生产者-消费者中，资源是两个线程之间的共享缓冲区。您希望确保使用者无法访问缓冲区，除非缓冲区已满；生产者无法访问缓冲区，除非缓冲区为空。您应该从消费者信号量中的计数0和生产者信号量中的计数1开始。这样生产者就必须采取第一步行动。当生产者开始写入缓冲区时，您希望

关闭生产者信号量。当生产者完成时，您希望
向上
消费者的信号量，这将允许消费者访问资源。当使用者访问了资源后，它会
up
s生产者的信号量，通知生产者缓冲区现在是空的

以此为起点：
导入java.util.Vector；
导入java.util.concurrent.Semaphore；
公共班机{
公共静态void main（字符串[]args）{
信号量互斥=新信号量（1）；
向量=新向量（）；
新生产者（向量，互斥体）.start（）；
新使用者（向量、互斥体）.start（）；
}
}
类生成器扩展线程{
私有向量v；
专用信号量互斥；
公共生产者（向量v，信号量互斥）{
这个，v=v；
this.mutex=mutex；
}
公开募捐{
字符串s；
while（true）{
试一试{
mutex.acquire（）；
s=“Value”+Math.random（）；
v、 增编；
System.out.println（“制作人创建的”+s）；
mutex.release（）；
sleep（（int）（100*Math.random（））；
}捕捉（中断异常e1）{
e1.printStackTrace（）；
}
}
}
}
类使用者扩展线程{
私有向量v；
专用信号量互斥；
公共使用者（向量v、信号量互斥）{
这个，v=v；
this.mutex=mutex；
}
公开募捐{
while（true）{
试一试{
mutex.acquire（）；
如果（v.size（）>0）{
系统输出打印（“消费者发现”+（字符串）v.elementAt（0））；
v、 removeElementAt（0）；
System.out.println（“（（发回：+v.size（）+”）”）；
}
mutex.release（）；
sleep（（int）（100*Math.random（））；
}捕捉（中断异常e1）{
e1.printStackTrace（）；
}
}
}
}
Hey nLee，。。今天我请一位老师向我解释每件事的细节，他像你一样向我解释。。。我非常感谢你的回答。你和stackdev帮了我很多，一点问题都没有。很乐意帮忙！非常感谢你，斯塔克德夫！
import java.util.Vector;
import java.util.concurrent.Semaphore;

public class Main {
    public static void main(String[] args) {
        Semaphore mutex = new Semaphore(1);
        Vector<String> vector = new Vector<>();
        new Producer(vector, mutex).start();
        new Consumer(vector, mutex).start();
    }
}

class Producer extends Thread {
    private Vector v;
    private Semaphore mutex;

    public Producer(Vector v, Semaphore mutex) {
        this.v = v;
        this.mutex = mutex;
    }

    public void run() {
        String s;

        while (true) {
            try {
                mutex.acquire();
                s = "Value" + Math.random();
                v.addElement(s);
                System.out.println("Producer created " + s);
                mutex.release();
                Thread.sleep((int) (100 * Math.random()));
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }

        }
    }
}


class Consumer extends Thread {
    private Vector v;
    private Semaphore mutex;

    public Consumer(Vector v, Semaphore mutex) {
        this.v = v;
        this.mutex = mutex;
    }

    public void run() {
        while (true) {
            try {
                mutex.acquire();
                if (v.size() > 0) {
                    System.out.print(" Consumer found " + (String) v.elementAt(0));
                    v.removeElementAt(0);
                    System.out.println(" (remaning: " + v.size() + ")");
                }
                mutex.release();
                Thread.sleep((int) (100 * Math.random()));
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
        }
    }
}