相关疑难解决方法(0)

有人可以解释一下(代码)的例子,死锁和活锁之间的区别是什么？

我是否可以获得一个完整的简单场景,即教程,建议如何使用它,特别是使用队列？

线程状态WAIT和线程状态BLOCKED之间有什么区别？

该Thread.State文档:

已
阻止等待监视器锁定的线程处于此状态.

正在
等待另一个线程无限期地执行特定操作的线程处于此状态

没有解释给我的区别.

为什么java.lang.Object有两种通知方法 - notify和notifyAll？似乎notifyAll至少一切都notify做了,所以为什么不一直使用notifyAll？如果notifyAll用来代替notify,程序是否仍然正确,反之亦然？是什么影响了这两种方法之间的选择？

public class GuardedBlock {

    private boolean guard = false;

    private static void threadMessage(String message) {
        System.out.println(Thread.currentThread().getName() + ": " + message);
    }

    public static void main(String[] args) {
        GuardedBlock guardedBlock = new GuardedBlock();

        Thread thread1 = new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    guardedBlock.guard = true;
                    threadMessage("Set guard=true");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        Thread thread2 = new Thread(new Runnable() {

            @Override
            public void run() {
                threadMessage("Start waiting");
                while (!guardedBlock.guard) {
                    //threadMessage("Still …

Delphi Docwiki解释说,Pulse通知等待队列中的下一个线程,一旦调用线程释放对象,它就能锁定指定的对象.PulseAll发信号通知等待队列中的所有线程.

我发现这个代码在线程队列实现中使用Pulse,并且根据上面的定义,认为应该使用PulseAll - 或者以不同的方式询问:何时使用Pulse而不是PulseAll是正确的？(基本问题在于:如何确保队列中的'下一个线程'是需要通知的线程,除非在总共只有两个线程的简单情况下,或者代码可以安全假设唯一等待的线程是需要被nofified /'pulsed'的线程？)？

function TSimpleThreadedQueue.Enqueue(const Item: T; Timeout: LongWord): TWaitResult;
begin
  if Closed then Exit(wrAbandoned);
  if not TMonitor.Enter(FQueue, Timeout) then Exit(wrTimeout);
  try
    if Closed then Exit(wrAbandoned);
    FQueue.Enqueue(Item);
    TMonitor.Pulse(FQueue);
    Result := wrSignaled;
  finally
    TMonitor.Exit(FQueue);
  end;
end;

对于Java语言中的相应同步方法,我发现了这个问题:Java:notify()与notifyAll()一遍又一遍

更新:上面链接的Java问题有一个有趣的答案,它显示了即使在生成器/消费者应用程序中也会发生死锁,该应用程序只有两个方法,put和get,以及使用notify()(Pulse()的Java副本) :Java:再次通知()和notifyAll()

答案包含建议

如果您不确定使用哪个,请使用notifyAll.

有时我需要醒来或发送一个单独的线程,我想知道什么是最好和最有效的方法.

第一个解决方案是信号结合wait-notify(我知道如何正确实现这种模式,这不是问题).

我在某处读到了使用java.concurrent库和CountDownLatch信令的效率更高.我也检查了concurrent.locks.Condition,但是这个主题声明它只是一个(程序员方面的)更安全和通用的结构,与之相比没有性能优势notify/notifyAll.彼得Lawrey建议使用并发库,而不是notify-notifyAll在这个意见,所以现在我感到困惑的是要使用的最佳实践.

一个相关的问题:哪个性能更好,notify或者notifyAll在我的情况下(即如果我有一个线程)？我知道有很多类似的线索,但没有一个给出明确的答案.在我的情况下,功能上,我使用哪个并不重要,但我想知道哪个更快.

试图了解wait()和notify().我知道线程何时A进入wait()它将被notify()其他线程唤醒.

但究竟会发生什么,如果线程A,B,C去wait()以表示订单？谁会被唤醒notify()？根据我的实验,A线程将首先被唤醒.我是正确的？

这是否意味着系统知道线程的顺序是wait()什么？

我正在尝试在java中创建线程安全队列。我遇到过这个例子：

class ProducerConsumer<T> {
   private static final int BUFFER_MAX_SIZE = 42;
   private List<T> buffer = new LinkedList<>();

   synchronized void produce(T value) throws InterruptedException {
      while (buffer.size() == BUFFER_MAX_SIZE) {
         wait();
      }
      buffer.add(value);
      notify();
   }

   synchronized T consume() throws InterruptedException {
      while (buffer.size() == 0) {
         wait();
      }
      T result = buffer.remove(0);
      notify();
      return result;
   }
}

我是java新手。据我了解，这两个“同步”关键字将防止每个方法内部发生争用，但当同时调用两个方法时则不会。例如，线程P调用product、locks方法，线程C调用consume、locks其他方法，然后一个尝试从列表中提取元素，另一个尝试插入元素，就会出现线程异常。

我的问题：这个例子坏了吗？

或者也许我错过了一些东西，但没关系。