Die Codekopie lautet wie folgt:
Paket com.yao;
import Java.util.concurrent.executorService;
import Java.util.concurrent.executors;
import Java.util.concurrent.future;
import Java.util.concurrent.locks.lock;
import Java.util.concurrent.locks.readwritelock;
import Java.util.concurrent.locks.reentrantlock;
import Java.util.concurrent.locks.reentranTreadWriteLock;
/**
* Schließfächer
* Ein wichtiges Konzept in der Multi-Thread-Programmierung ist das Sperren.
* Bei der Durchführung von Transaktionsvorgängen muss die gemeinsame Ressource gesperrt werden, wodurch sichergestellt wird, dass bei der Durchführung von Transaktionsvorgängen nur ein Thread auf der Ressource arbeiten kann.
* Dies stellt die Integrität der Daten sicher. Vor 5.0 wurde die Sperrfunktion durch das synchronisierte Schlüsselwort implementiert.
*/
öffentliche Klassenschließfächer {
/**
* Testen Sie die Verwendung von Schloss. Durch die Verwendung von Sperre in der Methode kann das synchronisierte Schlüsselwort vermeiden.
*/
öffentliche statische Klasse lockest {
Lock Lock = New Reentrantlock (); // Sperre
Double Value = 0d;
int addtimes = 0;
/**
* Erhöhen Sie den Wert des Wertes.
* Daher muss die Methode synchronisiert werden. Die vorherige Praxis bestand darin, das synchronisierte Schlüsselwort in der Methodenerklärung zu verwenden.
*/
public void addValue (double v) {
lock.lock (); // das Schloss erhalten
System.out.println ("LockTest to AddValue:" + V + "" "
+ System.currentTimemillis ());
versuchen {
Thread.sleep (1000);
} catch (InterruptedException e) {
}
this.Value += v;
this.addtimes ++;
lock.unlock (); // das Schloss freigeben
}
public double getValue () {
kehre diesen Wert zurück;
}
}
public static void testplockTest () löst Ausnahme {aus {
endgültig lockest lockest = new lockest ();
// Erstellen Sie eine neue Aufgabe 1 und rufen Sie die AddValue -Methode von LockTest auf
Runnable Task1 = new Runnable () {
public void run () {
lockTest.addValue (55,55);
}
};
// Erstellen Sie eine neue Aufgabe 2 und rufen Sie die GetValue -Methode von LockTest auf
Runnable Task2 = new Runnable () {
public void run () {
System.out.println ("Wert:" + lockTest.getValue ());
}
};
// Erstellen Sie einen neuen Aufgabenausführungsdienst
ExecutorService CachedService = Executors.NewCachedThreadpool ();
Zukünftige Zukunft = null;
// Aufgabe 1 dreimal zur gleichen Zeit ausführen.
für (int i = 0; i <3; i ++) {
Future = CachedService.Submit (Task1);
}
// Warten Sie, bis die letzte Aufgabe 1 ausgeführt wird
future.get ();
// Aufgabe 2 erneut ausführen, um das Ergebnis auszugeben
Future = CachedService.Submit (Aufgabe2);
// Schließen Sie den Aufgabenausführungsdienst, nachdem Sie auf die Ausführung von Aufgabe 2 gewartet haben
future.get ();
CachedService.Shutdownnow ();
}
/**
* ReadWriteLock hat zwei eingebaute Schlösser, eine ist das Leseschloss und das andere ist das geschriebene Schloss.
* Mehrere Threads können gleichzeitig gelesene Schlösser erhalten, aber nur ein Thread kann geschriebene Schlösser erhalten.
* Und nachdem das schriftliche Schloss gesperrt ist, kann kein Thread das Schloss erhalten. Die von ReadWriteLock bereitgestellten Methoden sind:
* Readlock (): Gibt ein Leseschloss zurück
* Writelock (): Gibt ein schriftliches Schloss zurück, dieses Schloss ist exklusiv.
* ReadWriteLockTest ist sehr geeignet, um Lese- und Schreibvorgänge ähnlicher Dateien zu behandeln.
* Sie können gleichzeitig beim Lesen lesen, aber Sie können nicht gleichzeitig schreiben oder gleichzeitig beim Schreiben lesen.
*/
öffentliche statische Klasse ReadWriteLockTest {
// Sperren
ReadWriteLock Lock = new ReentranTreadWriteLock ();
// Wert
Doppelwert = 0d;
int addtimes = 0;
/**
* Erhöhen Sie den Wertwert und lassen Sie nicht zulassen, dass mehrere Threads gleichzeitig die Methode eingeben.
*/
public void addValue (double v) {
// WriteLock und Lock bekommen
Lock WriteLock = lock.WriteLock ();
WriteLock.lock ();
System.out.println ("ReadWriteLockTest zu AddValue:" + V + "" "
+ System.currentTimemillis ());
versuchen {
Thread.sleep (1000);
} catch (InterruptedException e) {
}
versuchen {
// die Schreibarbeit erledigen
this.Value += v;
this.addtimes ++;
} Endlich {
// das Writelock Lock veröffentlichen
WriteLock.unlock ();
}
}
/**
* Informationen erhalten. Wenn ein Thread die AddValue -Methode aufruft, sind die von GetInfo erhaltenen Informationen möglicherweise falsch.
* Daher ist es auch notwendig, sicherzustellen, dass beim Aufrufen der Methode keine Methode die AddValue -Methode aufgerufen wird.
*/
public String getInfo () {
// Holen Sie sich Readlock und Sperre
Lock readlock = lock.readlock ();
Readlock.lock ();
System.out.println ("ReadWriteLockTest to GetInfo" "
+ System.currentTimemillis ());
versuchen {
Thread.sleep (1000);
} catch (InterruptedException e) {
}
versuchen {
// Die Lesearbeit erledigen
zurückgeben. Wert + ":" + this.addtimes;
} Endlich {
// Readlock veröffentlichen
Readlock.unlock ();
}
}
}
public static void testreadWriteLockTest () löst Ausnahme {aus {
endgültiger ReadWriteLockTest ReadWriteLockTest = new ReadWriteLockTest ();
// Erstellen Sie eine neue Aufgabe 1 und rufen Sie die AddValue -Methode von LockTest auf
Runnable task_1 = new Runnable () {
public void run () {
ReadWriteLockTest.AddValue (55,55);
}
};
// Erstellen Sie eine neue Aufgabe 2 und rufen Sie die GetValue -Methode von LockTest auf
Runnable task_2 = new Runnable () {
public void run () {
System.out.println ("Info:" + ReadWriteLockTest.getInfo ());
}
};
// Erstellen Sie einen neuen Aufgabenausführungsdienst
ExecutorService CachedService_1 = Executors.NewCachedThreadpool ();
Future Future_1 = NULL;
// 5 Aufgaben gleichzeitig ausführen, von denen die ersten 2 Aufgaben Task_1 und die letzten beiden Aufgaben sind Task_2 sind
für (int i = 0; i <2; i ++) {
Future_1 = CachedService_1.Submit (Task_1);
}
für (int i = 0; i <2; i ++) {
Future_1 = CachedService_1.Submit (Task_2);
}
// Die letzte Aufgabe ist Task_1
Future_1 = CachedService_1.Submit (Task_1);
// Die Ausführungsreihenfolge dieser 5 Aufgaben sollte sein:
// Der erste Task_1 wird zuerst ausgeführt, und der zweite Task_1 wird erneut ausgeführt.
// Dann werden zwei Task_2 gleichzeitig ausgeführt.
// Da sie gleichzeitig gelesen werden können, werden sie gleichzeitig ausgeführt
// Der letzte Task_1 wird erneut ausgeführt. Dies liegt daran, dass Sie beim Lesen nicht schreiben können. Sie müssen also warten, bis das Lesen vorbei ist, bevor Sie schreiben können.
// Warten Sie, bis der letzte Task_2 ausgeführt wird
Future_1.get ();
CachedService_1.Shutdownnow ();
}
public static void main (String [] args) löst Ausnahme {aus {
Schließfächer.TestLockTest ();
System.out.println ("---------------------");
Schließfächer.TestreadWriteLockTest ();
}
}