Synchronisation vs verrouillage

vous pouvez réaliser tout ce que les utilitaires en java.util.simultané faire avec le faible niveau des primitives comme synchronized , volatile , ou attendre / notifier

cependant, la concurrence est délicate, et la plupart des gens obtiennent au moins certaines parties erronées, ce qui rend leur code soit incorrect ou inefficace (ou les deux).

L'API concurrente fournit une approche de plus haut niveau, qui est plus facile (et donc plus sûr) à utiliser. En un mot, vous ne devriez plus avoir besoin d'utiliser synchronized, volatile, wait, notify directement.

la classe Lock elle-même est au niveau inférieur de cette boîte à outils, vous ne pouvez même pas avoir besoin d'utiliser directement non plus (vous pouvez utiliser Queues et sémaphore et des trucs, etc, la plupart du temps).

Il existe 4 principaux facteurs pourquoi vous voulez utiliser synchronized ou java.util.concurrent.Lock .

Note: le verrouillage synchronisé est ce que je veux dire quand je dis verrouillage intrinsèque.

1. quand Java 5 est sorti avec ReentrantLocks, ils se sont avérés avoir tout à fait un noticeble débit différence puis verrouillage intrinsèque. Si vous cherchez un verrouillage plus rapide mécanisme et sont en cours d'exécution de 1,5 envisager j.u.c.ReentrantLock. Java 6 intrinsèque le verrouillage est maintenant comparable.

2. J. U. C. La serrure a différents mécanismes pour le verrouillage. Verrouillage interruptable - tenter de verrouiller jusqu'au verrouillage le fil est interrompu; verrouillage chronométré - tenter de verrouiller pour une certaine quantité et si vous n'avez pas succès; tryLock-tentative de verrouillage, si un autre fil tient le la serrure abandonne. Tout cela est inclus à part la simple serrure. Offre de verrouillage intrinsèque uniquement simple verrouillage

3. Style. Si 1 et 2 ne tombent pas en catégories de ce que vous êtes concernées par la plupart des gens, y compris moi-même, serait de trouver la semenatiques de verrouillage intrinsèques plus faciles à lire et moins verbeux alors j.u.c.Serrure de verrouillage.
4. Conditions Multiples. Un objet vous verrouillage ne peut être notifié et attendu pour un seul cas. Verrouillage la méthode newCondition permet seule Serrure avoir plusieurs raisons attendre ou signaler. Je n'ai pas encore besoin de cette fonctionnalité dans pratique, mais est une belle caractéristique pour ceux qui en ont besoin.

je voudrais ajouter quelques choses en plus de Bert f réponse.

Locks supportent diverses méthodes de contrôle des serrures à grain plus fin, qui sont plus expressives que les moniteurs implicites ( synchronized serrures)

une serrure fournit un accès exclusif à une ressource partagée: un seul thread à la fois peut acquérir la serrure et tout accès à la ressource partagée nécessite que la serrure soit acquise premier. Cependant, certains verrous peuvent permettre l'accès simultané à une ressource partagée, comme le verrou en lecture d'un ReadWriteLock.

Avantages Lock " Synchronisation à partir de la documentation page

1. l'utilisation de méthodes ou d'énoncés synchronisés permet d'accéder au moniteur implicite de verrouillage associé à chaque objet, mais force l'acquisition de toutes les serrures et libération devant se produire d'une manière structurée par blocs

2. Verrouiller les implémentations de fournir des fonctionnalités supplémentaires par rapport à l'utilisation de la synchronisation des méthodes et des déclarations en fournissant un non-tentative de blocage pour acquérir un lock (tryLock()) , une tentative d'acquérir le verrou qui peut être interrompue ( lockInterruptibly() , et une tentative d'acquérir le verrou qui peut timeout (tryLock(long, TimeUnit)) .

3. une classe de serrure peut également fournir le comportement et la sémantique est très différente de celle du verrouillage implicite du moniteur, tel que commande Garantie, utilisation non réentrante ,ou Détection de blocage

ReentrantLock : en termes simples selon mon interprétation, ReentrantLock permet à un objet de rentrer d'une section critique à une autre section critique . Puisque vous avez déjà verrouillé pour entrer une section critique, vous pouvez d'autres critiques section sur le même objet en utilisant la serrure courante.

ReentrantLock caractéristiques clés selon cet article

1. capacité de verrouiller de façon interruptible.
2. capacité de temporiser en attendant le verrouillage.
3. puissance pour créer une serrure juste.
4. API pour obtenir la liste des threads en attente de verrouillage.
5. flexibilité pour essayer de verrouiller sans blocage.

vous pouvez utiliser ReentrantReadWriteLock.ReadLock, ReentrantReadWriteLock.WriteLock pour acquérir le contrôle sur le verrouillage granulaire sur les opérations de lecture et d'écriture.

mis à part ces trois boucles de rentrée, java 8 fournit une serrure de plus

StampedLock:

Java 8 navires avec un nouveau type de serrure appelé StampedLock qui prennent également en charge la lecture et l'écriture des serrures comme dans l'exemple ci-dessus. Dans contrairement à ReadWriteLock les méthodes de verrouillage d'un timbré renvoient un timbré représenté par une valeur longue.

vous pouvez utiliser ces timbres pour libérer une serrure ou pour vérifier si la serrure est toujours valide. De plus, les serrures timbrées supportent un autre mode de verrouillage appelé verrouillage optimiste.

Avoir un oeil à cette article sur l'utilisation de différents types de ReentrantLock et StampedLock verrous.

la principale différence est l'équité, en d'autres termes, les demandes sont-elles traitées par L'IFOP ou peut-il y avoir marchandage? La synchronisation du niveau de la méthode garantit une répartition équitable ou FIFO de la serrure.

synchronized(foo) {
}

ou

lock.acquire(); .....lock.release();

ne garantit pas l'équité.

si vous avez beaucoup de contestations pour la serrure, vous pouvez facilement rencontrer le marchandage où les requêtes plus récentes obtiennent la serrure et les requêtes plus anciennes sont bloquées. J'ai vu des cas où 200 threads arrivent en peu de temps pour une serrure et le 2ème pour arriver a été traité en dernier. C'est ok pour certaines applications, mais pour d'autres, c'est mortel.

voir le livre de Brian Goetz, "Java Competiency In Practice", section 13.3, pour une discussion complète de ce sujet.

Livre de Brian Goetz, "Java Competiency In Practice", section 13.3: "...Comme le verrouillage de rentrée par défaut, le verrouillage intrinsèque n'offre aucune garantie déterministe d'équité, mais le les garanties d'équité statistique de la plupart des implémentations de verrouillage sont suffisantes pour presque toutes les situations..."

La serrure

facilite la vie des programmeurs. Voici quelques situations qui peuvent être atteints plus facilement avec serrure.

1. verrouiller une méthode, et libérer la serrure dans une autre méthode.
2. vous avez deux threads travaillant sur deux morceaux de code différents, cependant le premier thread il y a une dépendance sur le deuxième thread pour compléter un certain morceau de code avant qu'il ne continue plus (tandis que d'autres threads travaillent aussi simultanément). Un verrou partagé peut résoudre ce problème très facilement.
3. la mise en Œuvre de moniteurs. Par exemple, une file d'attente simple où les méthodes put et get sont exécutées à partir de nombreux threads différents. Toutefois, voulez-vous sur les genoux ni les mêmes méthodes, l'une sur l'autre, ni les deux méthodes put et get peuvent se chevaucher. Dans ce cas, une serrure privée rend la vie plus facile.

tandis que, la serrure, et les conditions sont construits sur le synchronisé. Donc, vous pouvez certainement accomplir la même chose objectif avec qui. Cependant, cela pourrait rendre votre vie difficile et peut vous détourner de la résolution du problème réel.

la principale différence entre serrure et synchronisé est - avec les serrures, vous pouvez libérer et acquérir les serrures dans n'importe quel ordre. - synchronisé, vous pouvez libérer les verrous seulement dans l'ordre qu'il a acquis.

Lock and synchronize block sert le même but, mais cela dépend de l'usage. Considérez la partie ci-dessous

void randomFunction(){
.
.
.
synchronize(this){
//do some functionality
}

.
.
.
synchronize(this)
{
// do some functionality
}


} // end of randomFunction

Dans le cas ci-dessus , si un fil entre le synchroniser bloc, l'autre bloc est également verrouillé. S'il y a plusieurs blocs synchrones sur le même objet, tous les blocs sont verrouillés. Dans de telles situations , java.util.simultané.Serrure peut être utilisé pour empêcher le verrouillage non désiré des blocs