Comment déterminer si un objet est verrouillé (synchronisé) afin de ne pas bloquer en Java?

Une chose à noter est que le instant vous recevoir de telles informations, il est éventé. En d'autres termes, vous pourriez être dit que nul n'a le verrou, mais ensuite, lorsque vous essayez d'acquérir, vous bloquer parce qu'un autre thread a pris la serrure entre les vérifier et tenter de l'acquérir.

Brian est juste à point à Lock, mais je pense que ce que vous voulez vraiment est son tryLock méthode:

Lock lock = new ReentrantLock();
......
if (lock.tryLock())
{
    //Got the lock
    try
    {
        //Process record
    }
    finally
    {
        //Make sure to unlock so that we don't cause a deadlock
        lock.unlock();
    }
}
else
{
    //Someone else had the lock, abort
}

Vous pouvez également appeler tryLock avec une quantité de temps à attendre - de sorte que vous pourraient tenter en acquérir pour un dixième de seconde, puis abandonner si vous ne pouvez pas l'obtenir (par exemple).

(Je pense que c'est dommage que l'API Java n'est pas pour autant que je suis au courant - fournir les mêmes fonctionnalités pour le "built-in" de verrouillage, comme le Monitor classe dans .NET. Puis de nouveau, il ya beaucoup d'autres choses que je n'aime pas dans les deux plates-formes quand il s'agit de filetage - chaque objet ayant potentiellement un moniteur, par exemple!)

Tandis que l'approche ci-dessus à l'aide d'un Verrou d'objet est la meilleure façon de le faire, si vous avez d'être en mesure de vérifier de verrouillage à l'aide d'un moniteur, il peut être fait. Cependant, il ne viennent avec un avertissement de santé publique, car la technique n'est pas portable pour non Oracle de machines virtuelles Java et il peut se casser à l'avenir VM versions comme il n'est pas pris en charge API publique.

Voici comment le faire:

private static sun.misc.Unsafe getUnsafe() {
    try {
        Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
        field.setAccessible(true);
        return (Unsafe) field.get(null);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public void doSomething() {
  Object record = new Object();
  sun.misc.Unsafe unsafe = getUnsafe(); 
  if (unsafe.tryMonitorEnter(record)) {
    try {
      //record is locked - perform operations on it
    } finally {
      unsafe.monitorExit(record);
    }
  } else {
      //could not lock record
  }
}

Mon conseil serait d'utiliser cette méthode uniquement si vous ne pouvez pas restructurer le code à utiliser java.util.simultanées de Verrouiller des objets pour cela, et si vous êtes en cours d'exécution sur un Oracle VM.

Pendant que le Verrou réponses sont très bon, je pensais que je poste une alternative en utilisant une autre structure de données. Essentiellement, vos différents threads veulent savoir quels enregistrements sont verrouillés et qui ne le sont pas. Une façon de le faire est de garder une trace de l'verrouillé dossiers et assurez-vous que la structure de données a le droit d'opérations atomiques pour ajouter des enregistrements à la verrouillés ensemble.

Je vais utiliser CopyOnWriteArrayList comme exemple parce que c'est moins "magique" pour l'illustration. CopyOnWriteArraySet est plus approprié de la structure. Si vous avez des tas de dossiers verrouillés dans le même temps, en moyenne, il peut y avoir des implications sur les performances de ces implémentations. Un correctement synchronisés HashSet serait trop de travail et les serrures sont de courte durée.

Fondamentalement, l'utilisation de code devrait ressembler à ceci:

CopyOnWriteArrayList<Record> lockedRecords = ....
...
if (!lockedRecords.addIfAbsent(record))
    return; //didn't get the lock, record is already locked

try {
    //Do the record stuff
}        
finally {
    lockedRecords.remove(record);
}

Il vous permet d'éviter d'avoir à gérer un verrouillage par enregistrement et offre un lieu unique devrait effacement de tous les verrous nécessaires pour une raison quelconque. D'autre part, si jamais vous avez plus d'une poignée de dossiers alors un véritable HashSet avec la synchronisation peut faire de mieux depuis l'ajout/suppression de look-up sera en O(1) au lieu de linéaire.

Juste une façon différente de voir les choses. Tout dépend de ce que votre réelle de filetage exigences. Personnellement, je voudrais utiliser une des Collections.synchronizedSet( new HashSet ()), car il sera très vite... la seule implication est que les threads peuvent produire quand ils n'aurait pas autrement.

Merci pour cela, il m'a aidé à résoudre une situation de concurrence. Je l'ai changé un peu de vêtements à la fois de la ceinture et des bretelles.

Donc, voici ma suggestion pour UNE AMÉLIORATION de la accepté de répondre:

Vous pouvez vous assurer que vous obtenez un accès sûr à l' tryLock() méthode en faisant quelque chose comme ceci:

  Lock localLock = new ReentrantLock();

  private void threadSafeCall() {
    boolean isUnlocked = false;

    synchronized(localLock) {
      isUnlocked = localLock.tryLock();
    }

    if (isUnlocked) {
      try {
        rawCall();
      }
      finally {
        localLock.unlock();
      }
    } else {
      LOGGER.log(Level.INFO, "THANKS! - SAVED FROM DOUBLE CALL!");
    }
  }

Cela permettrait d'éviter la situation où vous pourriez obtenir deux appels tryLock() au presque en même temps, de sorte que le retour à être potentiellement doute plein. J'aimerais maintenant si je me trompe, je suis peut-être plus de cautios ici. Mais hey! Mon boulot est stable maintenant :-)..

Lire plus sur mes questions de développement à mon Blog.