如何使用信号量进行信令？

Question

现在我研究信号量。我搜索了有关此主题的以下链接：

link

此链接的作者撰写了有关使用信号量进行信号传输的文章。为了展示它是如何工作的，他编写了自定义信号量。

自定义信号量代码：

public class Semaphore {
  private boolean signal = false;

  public synchronized void take() {
    this.signal = true;
    this.notify();
  }

  public synchronized void release() throws InterruptedException{
    while(!this.signal) wait();
    this.signal = false;
  }

}

关于如何在他编写的代码中使用它：

public class SendingThread {
  Semaphore semaphore = null;

  public SendingThread(Semaphore semaphore){
    this.semaphore = semaphore;
  }

  public void run(){
    while(true){
      //do something, then signal
      this.semaphore.take();

    }
  }
}



public class RecevingThread {
  Semaphore semaphore = null;

  public ReceivingThread(Semaphore semaphore){
    this.semaphore = semaphore;
  }

  public void run(){
    while(true){
      this.semaphore.release();
      //receive signal, then do something...
    }
  }
}

主要：

Semaphore semaphore = new Semaphore();

SendingThread sender = new SendingThread(semaphore);

ReceivingThread receiver = new ReceivingThread(semaphore);

receiver.start();
sender.start();

据我了解，执行顺序应遵循

send - receive
send - receive
send - receive
...

我尝试使用此蓝图编写自己的代码

public class SendReceiveWithCustomSemaphore {
    public static void main(String[] args) {
        MySemaphore mySemaphore = new MySemaphore();
        new Send(mySemaphore).start();
        new Receive(mySemaphore).start();
    }
}

class MySemaphore {
    boolean flag = false;

    public synchronized void take() throws InterruptedException {
        flag = true;
        notify();
    }

    public synchronized void release() throws InterruptedException {
        while (!flag) {
            wait();
        }
        flag = false;
    }
}

class Send extends Thread {
    MySemaphore mySemaphore;

    public Send(MySemaphore semaphore) {
        this.mySemaphore = semaphore;
    }

    @Override
    public void run() {
        int i = 0;
        while (i++ < 10) {
            System.out.println("send");
            try {
                mySemaphore.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Receive extends Thread {
    MySemaphore mySemaphore;

    public Receive(MySemaphore semaphore) {
        this.mySemaphore = semaphore;
    }

    @Override
    public void run() {
        while (true) {
            try {
                mySemaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("receive");
        }
    }
}

输出：

send
send
send
send
send
send
send
send
send
send
receive

因此，这不是我预期的行为。

是我写错了代码还是没看懂概念？

作者想说什么？

Answer 1

找到更好的教程。

您看到的输出与我预期的差不多。 “sender”线程永远不会阻塞，所以它会一直打印“send”、“send”、“send”。同时，在“receiver”线程中，每次调用 semaphore.release() 方法时，都会阻塞，直到下一次 sender 开始运行。

我希望看到很多“发送”消息，偶尔会混入“接收”消息——或多或少与您所描述的一样。

我不知道这个例子应该证明什么，但对我来说，它给人的印象是作者不知道程序员期望信号量如何表现。

一些作者提供了不应该做的例子，或者包含将在后面的例子中“修复”的故意错误的例子。你确定你不是在效仿这种例子吗？

编辑：我点击了链接，看起来主要问题是在 take() 和 release() 方法的定义中交换了名称。如果只是换个名字，那就更有意义了。

Answer 2

到 ReceiveSemafore 启动时，SendSemafore 已经执行了 10 次。

考虑使用CountDownLatch 同时启动两个线程。尽管正如 Fuhrmanator 指出的那样，这不会产生您正在寻找的交替输出。

为此，我将使用带一个信号的有界信号量。