tryLock 上的 Java IllegalMonitorStateException

Question

我想知道是否有人可以帮助我。我是并发编程的新手，我有以下代码，有时会给我一个 IllegalMonitorStateException 作为当前不拥有锁的线程正在尝试解锁。

我在 OTN 论坛上被告知，为了防止这种情况和死锁发生，我应该确保首先锁定最低的索引，但我不知道如何做到这一点。你们中的谁能指出我正确的方向吗？

非常感谢。

         import java.util.concurrent.locks.*;
         class ShuffleBase {

         ReentrantLock [] locker;
         int [] data;
         int x;
         ReentrantLock lock1;
         ReentrantLock lock2;

         public ShuffleBase(int [] d){
         x=0;
        data=d;
        locker = new ReentrantLock[d.length];
        while (x!=data.length)
        {
         locker[x]=new ReentrantLock();   
          x++;
        }
        }


     /*
      *  Boolean method to test if both indexes are locked
      *  Returning their status for use in the method swap
      *  If locked the swap happens else the locks are 
      *  released
      */
      public boolean lockedIndex(int a, int b){

      Boolean lockA = false;

      Boolean lockB = false;

      try{

      lockA = lock1.tryLock();

      lockB = lock2.tryLock(); 
       }finally{

          if (!(lockA && lockB))
      {

       if(lockA){
         lock1.unlock();       
        }
       if (lockB){
        lock2.unlock();
         }  
           }// end of IF ! lockA & lockB

      } // End of finally
      return lockA && lockB;
    }// End of lockedIndex


     public void swap(int a, int b){

      int temp;

      lock1 = locker[a];
      lock2=locker[b];



      //If a & b aren't the same index swap
       if(a!=b)
        {   
        if(lockedIndex(a,b))
        {
         try{
          temp=data[b];

         data[b]=data[a];

         data[a]=temp;

          }finally{
            lock1.unlock(); 
                       lock2.unlock();

          }
         }
         else{System.out.println("Couldn't lock");}   

        }
       else{return;}

    }//EOF Method

    public void display(){
    System.out.println("The array when swapped");
    for(int j=0; j<data.length;j++)
    {
     System.out.print(data[j]+", ");
    }
    }// End of Display


     }// EOC

<小时/>

谢谢大家的回答，是的，我这样做是作为自学/作业的一部分。我已将代码更改为以下内容，因为我相信这就是 Rodion 的建议，我希望我正确解释了您的建议。 Mtraut 我也做了你建议的更改，我不敢相信我犯了这些错误:-) 感谢您发现它们。

import java.util.concurrent.locks.*;
class ShuffleBase {

ReentrantLock [] locker;
int [] data;
int x=0;


public ShuffleBase(int [] d){
  data=d;
  locker = new ReentrantLock[d.length];
  while (x!=data.length)
   {
     locker[x]=new ReentrantLock();   
      x++;
   }
}


 /*
  * Boolean method to test if both indexes are locked
  *  Returning their status for use in the method swap
  *  If locked the swap happens else the locks are 
  *  released
  */
  private boolean lockedIndex(int a, int b){

   Boolean lockA = false;

   Boolean lockB = false;

    try{

        lockA = locker[a].tryLock();

        lockB = locker[b].tryLock(); 
        }finally{

         if (!(lockA && lockB))
             {

                 if(lockA){
                 locker[a].unlock();       
                 }

                 if (lockB){
                   locker[b].unlock();
                 }  
             }// end of IF ! lockA & lockB

       } // End of finally
           return lockA && lockB;
    }// End of lockedIndex


public void swap(int a, int b){

 int temp; 

 //If a & b aren't the same index swap
   if(a!=b)
          {   
            if(lockedIndex(a,b))
              {
                 try{
                      temp=data[b];
                      data[b]=data[a];
                      data[a]=temp;
                     }finally{
                              locker[a].unlock(); 
                              locker[b].unlock();
                              }
               }
             else{System.out.println("Couldn't lock");}   
           }
           else{System.out.println(return;}

       }//EOF Method

   public void display(){
       System.out.println("The array when swapped");
       for(int j=0; j<data.length;j++)
           {
              System.out.print(data[j]+", ");
           }
       }// End of Display

  }// EOC

再次感谢您的所有回答，并对我迟到的回复表示歉意。

Answer 1

以下是针对您的程序的快速修复:

1. 摆脱lock1和lock2领域，它们是你的源泉问题。
2. 替换所有引用至lock1与 locker[a]和 lock2与 locker[b] .

您的程序没有任何死锁问题，因为您正在使用 tryLock()所以你真的不需要担心这个。如果您使用lock()那么你需要考虑获取锁的顺序，否则可能会死锁(请参阅其他答案)。

现在你当前的程序有缺陷的原因是 lock1和lock2字段在线程之间共享。例如，线程 1 设置 lock1至locker[0] ，然后立即另一个 thread-2 覆盖 lock1将其设置为 locker[99] ，所以当 thread-1 尝试解锁 lock1 时它恰好引用了 locker[99]线程 2 获取的锁，因此 IllegalStateMonitorException .

希望这能解决问题。