Est-il un Mutex en Java?
Est-il un objet Mutex en java ou un moyen d'en créer un?
Je demande car un objet Sémaphore initialisé avec 1 permis de ne pas m'aider.
Pense de cette affaire:
try {
semaphore.acquire();
//do stuff
semaphore.release();
} catch (Exception e) {
semaphore.release();
}
si une exception se produit lors de la première acquisition, la libération dans le bloc catch va augmenter les permis, et le sémaphore n'est plus un sémaphore binaire.
Sera la bonne façon?
try {
semaphore.acquire();
//do stuff
} catch (Exception e) {
//exception stuff
} finally {
semaphore.release();
}
Sera le code ci-dessus vous assurer que le sémaphore sera binaire?
- Regardez la javadoc de java.util.de façon concomitante.les verrous.AbstractQueuedSynchronizer. Il a un exemple de la façon d'écrire une classe Mutex. -dbednar
- Avez-vous trouvé ce comportement de manière empirique? Est la mise en œuvre, telles que l'exécution de release() sur un 1-permis de Sémaphore ajoute un supplément de permis, même si ça tient actuellement un autre, vraiment ?
Vous devez vous connecter pour publier un commentaire.
Voir cette page: http://www.oracle.com/technetwork/articles/javase/index-140767.html
Elle a une évolution légèrement différente qui est (je pense) ce que vous cherchez:
Dans cette utilisation, il vous suffit d'appeler
release()
après un succèsacquire()
N'importe quel objet en Java peut être utilisé comme un verrou à l'aide d'un
synchronized
bloc. Ce sera aussi automatiquement prendre soin de libérer le verrou lorsqu'une exception se produit.Vous pouvez en lire plus à ce sujet ici: Intrinsèque de Serrures et de Synchronisation
synchronized
, vous verrez ce qui est le mieux lisible et moins sujette aux erreurs.transaction.begin(); transaction.commit()
).someObject.wait(timeout)
etsomeObject.notify()
pendant que vous êtes en train de regarder le code de cette réponse.private final ReentrantLock _mutex = ...
, vous pouvez utiliser getHoldCount() pour retourner le nombre de thread re-verrouille. (Vous pouvez appliquer unCondition
pour l'en empêcher. Voir l'API.)Personne n'a clairement parlé, mais ce genre de modèle est généralement pas adapté pour les sémaphores. La raison en est que tout thread peut lancer un sémaphore, mais vous ne voulez le propriétaire fil que initialement verrouillé pour être en mesure de déverrouiller. Pour ce cas d'utilisation, en Java, nous avons l'habitude d'utiliser ReentrantLocks, qui peut être créé comme ceci:
Et de l'habitude de modèle de conception de l'utilisation est:
Ici est un exemple dans le code source java, où vous pouvez voir ce modèle en action.
Réentrant serrures ont l'avantage d'appuyer l'équité.
Utiliser les sémaphores seulement si vous avez besoin de la non-propriété de la libération de la sémantique.
count=1
n'est pas un verrou d'exclusion mutuelle.Je pense que vous devriez essayer avec :
Tout Sémaphore initialisation :
Et dans votre
Runnable Implementation
Erreur dans le post original est acquire() de l'appel à l'intérieur de l'essayer en boucle.
Voici une bonne approche de l'utilisation de "binaire" sémaphore (Mutex):
Pour s'assurer qu'un
Semaphore
est binaire que vous avez besoin pour vous assurer de faire passer le nombre de permis 1 lors de la création du sémaphore. Le La documentation javadoc avoir une explication un peu plus.De chaque objet de verrouillage est un peu différent de Mutex/Sémaphore de la conception.
Par exemple, il n'existe aucun moyen pour mettre correctement en œuvre de la traversée de nœuds liés à la publication précédente du nœud de verrouillage et de capture suivante. Mais avec mutex il est facile à mettre en œuvre:
Actuellement, il n'existe pas de telle classe dans
java.util.concurrent
, mais vous pouvez trouver Mutext mise en œuvre ici Mutex.java. Comme pour les bibliothèques standard, Sémaphore offre toutes ces fonctionnalités et bien plus encore.