Question

ReceivingThread永远不会完全有可能执行并且SendingThread KEEEEEEPPPSSS .......执行时根本不会对Semaphore对象进行锁定吗？我从Jakob Jenkov concurrency tutorial

得到了这个例子

有人可以详细说明下面的例子，说明信号量实际上是如何表现为信号量吗？

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

class User{  
    public static void main(){  
        Semaphore semaphore = new Semaphore();  
        SendingThread sender = new SendingThread(semaphore);  
        ReceivingThread receiver = new ReceivingThread(semaphore);  
        receiver.start();  
        sender.start();  
    }  
}

Answer 1

首先，＆＃34;发件人＆＃34;也不是＆＃34;接收者＆＃34;似乎实际上是线程。（他们没有扩展＆＃34;线程＆＃34;。）

所讨论的信号量的行为类似于信号量，意思是可以等待它被释放，对于并发信令来说是不安全的。

另一方面，您已从上下文中获取了教程中的代码。阅读教程，并假设它试图教你一些东西。看起来接下来的段落可以解决您的问题。

自定义信号量和它的用法是否正确？

1 个答案: