• Startseite
  • Artikel
  • Allgemein
  • Was ist Lock(), UnLock(), ReentrantLock(), TryLock() und wie unterscheidet es sich von Synchronized Block in Java?]

Was ist Lock(), UnLock(), ReentrantLock(), TryLock() und wie unterscheidet es sich von Synchronized Block in Java?]

Veröffentlicht: 2020-07-05

In diesem Tutorial gehen wir auf Lock(), UnLock(), ReentrantLock(), TryLock() ein und wie es sich von Synchronized Block in Java unterscheidet.

Wenn Sie auch die folgenden Fragen haben, sind Sie hier richtig.

  • Sperren in Java
  • Beispiel für Java-Sperre und Parallelitätssperre vs. synchronisiert
  • Java Concurrency Tutorial – Wiedereintretende Sperren
  • Synchronisation – Korrekte Verwendung von Sperren/Entsperren für Java
  • java – Synchronisierung vs. Sperre
  • Beispiel für das Entsperren von Java-Sperren
  • Sperrmechanismus in java
  • Java-Sperre entsperrt anderen Thread

Lass uns anfangen. Lassen Sie uns zunächst jeden dieser Begriffe verstehen und dann das Arbeitsbeispiel durchgehen.

Sperren():

java.util.concurrent.locks . Eine Sperre ist ein Thread-Synchronisationsmechanismus wie synchronisierte Blöcke, außer dass Sperren ausgefeilter sein können als die synchronisierten Blöcke von Java. Es handelt sich um Schnittstellen und Klassen, die einen Rahmen zum Sperren und Warten auf Bedingungen bereitstellen, der sich von der integrierten Synchronisierung und den Monitoren unterscheidet.

Freischalten():

UnLock() hebt die Sperre auf Objekt auf.

ReentrantLock():

Eine ReentrantLock gehört dem Thread, der zuletzt erfolgreich gesperrt, aber noch nicht entsperrt wurde. Ein Thread, der eine lock aufruft, kehrt zurück und erwirbt die Sperre erfolgreich, wenn die Sperre keinem anderen Thread gehört. Die Methode kehrt sofort zurück, wenn der aktuelle Thread bereits die Sperre besitzt.

TryLock():

TryLock() erwirbt die Sperre nur, wenn sie zum Zeitpunkt des Aufrufs frei ist.

Tipp-1

Wenn Sie ein Objekt einfach sperren, würde ich es vorziehen, synchronized.

1
2
3
Lock . lock ( ) ;
youMethod ( ) ; // Throws a NullPointerException!
Lock . unlock ( ) ; // Here you never release the lock!

Während es bei der Synchronisierung super klar und unmöglich ist, etwas falsch zu machen:

1
2
3
synchronized ( myObject ) {
       doSomethingNifty ( ) ;
}

Beispieldetails:

  1. Klasse erstellen: CrunchifyLockTutorial.java
  2. Erstellen Sie innere Klassen: Company und CrunchifyLoop
  3. Erstellen Sie aus Main zwei Objekte der Klasse Company
  4. Starten Sie die Fadenschleife für 10 an diesen Objekten
  5. Während Company1 mit Company2 spricht, sperrt es ein Objekt. Wenn gleichzeitig – wenn Company2 mit Company1 sprechen möchte, dann heißt es – Konflikt – Sperre existiert bereits. (Beide Unternehmen sind bereits im Gespräch).
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
package crunchify . com . tutorial ;
 
import java . util . Random ;
import java . util . concurrent . locks . Lock ;
import java . util . concurrent . locks . ReentrantLock ;
 
/**
* @author Crunchify.com
*
*/
 
public class CrunchifyLockTutorial {
public static void main ( String [ ] args ) {
final Company crunchify = new Company ( "Crunchify" ) ;
final Company google = new Company ( "Google" ) ;
new Thread ( new CrunchifyLoop ( crunchify , google ) ) . start ( ) ;
new Thread ( new CrunchifyLoop ( google , crunchify ) ) . start ( ) ;
}
 
// Class CrunchifyLoop
static class CrunchifyLoop implements Runnable {
private Company companyName1 ;
private Company companyName2 ;
 
public CrunchifyLoop ( Company companyName1 , Company companyName2 ) {
this . companyName1 = companyName1 ;
this . companyName2 = companyName2 ;
}
 
public void run ( ) {
Random random = new Random ( ) ;
// Loop 10
for ( int counter = 0 ; counter < = 10 ; counter ++ ) {
try {
Thread . sleep ( random . nextInt ( 5 ) ) ;
} catch ( InterruptedException e ) {
}
companyName2 . crunchifyTalking ( companyName1 ) ;
}
}
}
 
// Class Company
static class Company {
private final String companyName ;
 
// ReentrantLock: Creates an instance of ReentrantLock. This is equivalent to using ReentrantLock(false)
private final Lock lock = new ReentrantLock ( ) ;
 
// Constructor
public Company ( String name ) {
this . companyName = name ;
}
 
public String getName ( ) {
return this . companyName ;
}
 
public boolean isTalking ( Company companyName ) {
Boolean crunchifyLock = false ;
Boolean googleLock = false ;
try {
// tryLock: Acquires the lock only if it is free at the time of invocation.
crunchifyLock = lock . tryLock ( ) ;
googleLock = companyName . lock . tryLock ( ) ;
} finally {
if ( ! ( crunchifyLock && googleLock)) {
if (crunchifyLock) {
// unlock: Releases the lock.
lock.unlock();
}
if ( googleLock ) {
companyName . lock . unlock ( ) ;
}
}
}
return crunchifyLock && googleLock;
}
 
public void crunchifyTalking ( Company companyName ) {
// Check if Lock is already exist?
if ( isTalking ( companyName ) ) {
try {
System . out . format ( "I'm %s: talking to %s %n" , this . companyName , companyName . getName ( ) ) ;
} finally {
lock . unlock ( ) ;
companyName . lock . unlock ( ) ;
}
} else {
System . out . format ( "\tLock Situation ==> I'm %s: talking to %s, but it seems"
+ " we are already talking. Conflicting. %n" , this . companyName , companyName . getName ( ) ) ;
}
}
}
}

Ausgabe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
I 'm Crunchify: talking to Google
Lock Situation ==> I' m Google : talking to Crunchify , but it seems we are already talking . Conflicting .
I 'm Google: talking to Crunchify
I' m Google : talking to Crunchify
I 'm Crunchify: talking to Google
I' m Google : talking to Crunchify
I 'm Google: talking to Crunchify
I' m Crunchify : talking to Google
Lock Situation == > I 'm Google: talking to Crunchify, but it seems we are already talking. Conflicting.
Lock Situation ==> I' m Crunchify : talking to Google , but it seems we are already talking . Conflicting .
Lock Situation == > I 'm Google: talking to Crunchify, but it seems we are already talking. Conflicting.
I' m Crunchify : talking to Google
I 'm Google: talking to Crunchify
I' m Google : talking to Crunchify
I 'm Crunchify: talking to Google
I' m Google : talking to Crunchify
Lock Situation == > I 'm Google: talking to Crunchify, but it seems we are already talking. Conflicting.
Lock Situation ==> I' m Crunchify : talking to Google , but it seems we are already talking . Conflicting .
I 'm Crunchify: talking to Google
I' m Crunchify : talking to Google
I 'm Crunchify: talking to Google
I' m Crunchify : talking to Google

Tipp-2

Sie können alles, was die Dienstprogramme in java.util.concurrent tun, mit den primitiven Elementen auf niedriger Ebene erreichen, wie synchronized “, volatile oder wait .