java多线程理解公平锁

Question

我试图理解java中的公平锁，并从中执行了一个实现

http://tutorials.jenkov.com/java-concurrency/starvation-and-fairness.html

哪个很好

代码如下所示

public class FairLock 
{
    private boolean           isLocked       = false;
    private Thread            lockingThread  = null;
    private List<QueueObject> waitingThreads =
            new ArrayList<QueueObject>();

  public void lock() throws InterruptedException
  {
    QueueObject queueObject           = new QueueObject();
    boolean     isLockedForThisThread = true;
    synchronized(this){waitingThreads.add(queueObject);}

    while(isLockedForThisThread)
    {
     synchronized(this)
     {
      isLockedForThisThread =
      isLocked || waitingThreads.get(0) != queueObject;
      if(!isLockedForThisThread)
      {
       isLocked = true;
       waitingThreads.remove(queueObject);
       lockingThread = Thread.currentThread();
       return;
     }
  }

  try{queueObject.doWait();}
  catch(InterruptedException e)
  {
    synchronized(this) { waitingThreads.remove(queueObject); }
    throw e;
  }
}
 }

  public synchronized void unlock()
  {
    if(this.lockingThread != Thread.currentThread())
    {
      throw new IllegalMonitorStateException(
        "Calling thread has not locked this lock");
    }

    isLocked      = false;
    lockingThread = null;

    if(waitingThreads.size() > 0){waitingThreads.get(0).doNotify();}
  }
}

队列对象的代码

public class QueueObject 
{

  private boolean isNotified = false;

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

  public synchronized void doNotify() 
  {
    this.isNotified = true;
    this.notify();
  }

  public boolean equals(Object o){return this == o;}
}

我了解其中的大部分，但我有两个疑问

1）在这一行代码中

   isLockedForThisThread =
   isLocked || waitingThreads.get(0) != queueObject;

这个零件是做什么用的？

waitingThreads.get(0) != queueObject;

它有什么作用？因为我删除了这部分代码，得到了相同的正确结果。

2） 因为我相信我不需要这部分代码，所以我将lock（）方法更改为下面给出的版本。

public void myLock() throws InterruptedException
{
    QueueObject queueObject= new QueueObject();
    synchronized(this){waitingThreads.add(queueObject);}

    while(true)
    {
      synchronized(this)
      {
       if(!isLocked)
       {
        isLocked = true;
        waitingThreads.remove(queueObject);
        lockingThread = Thread.currentThread();
        return;
       }
     }

     try{queueObject.doWait();}
     catch(InterruptedException e)
     {
       synchronized(this){waitingThreads.remove(queueObject);}
       throw e;
     }
   }

这也给了我正确的结果，但我相信我还没有研究过所有的案例，在某些情况下，这将失败，我希望基本上能得到专家的意见

.这在哪里起作用？

...它会在哪里失败？

我是新的多线程和基本上寻找一些解释（在第1部分）和反馈（在第2部分）我的问题

非常感谢。

Answer 1

注意这一行

synchronized(this){waitingThreads.add(queueObject);}

在这里，我们将新创建的队列对象添加到队列中，但我们是以同步方式进行的，因为可能有两个线程同时尝试将对象添加到列表中。记住这一点，让我们转到下一个同步块

isLockedForThisThread =
  isLocked || waitingThreads.get(0) != queueObject;

现在，如果另一个线程正在运行，那么这个线程将被锁定，理想情况下，它会将isLocked设置为true，所以您的问题是为什么我们也在做waitingThreads。获得（0）！=队列对象。想象一下，在前一个块中，线程A在线程B之前添加了一个对象到队列中，它是自己的，这将优先让A首先运行，现在线程A可能会被挂起，或者什么，线程B首先到达第二个同步块，让我们检查一下现在的情况：1。isLocked为false，因为还没有线程将其设置为true。A是队列中的第一个，然后是B3。线程B正在运行，而线程A挂起

现在，如果你按照你所做的去做，移除| | B的第二部分，你会认为该轮到它来获取锁了，并且会进入下一个“if”语句，这不是正确的行为，因为下面的一行将移除队列的第二个元素（在我们的示例中，它可能是第三个，在其他情况下甚至更多），而不是头要素

waitingThreads.remove(queueObject);

我不是专家的任何手段，但这是我看到的问题，希望我已经帮助它可以是棘手的，清楚地解释多线程的行为只使用文本： P