Java und die Synchronisation - Versionsgeschichte

L-ectron-X am 9. März 2018 um 15:05 Uhr

2018-03-09T15:05:33Z

AndreUhres: /* Grenzen */

2011-03-17T15:34:35Z

Grenzen

← Nächstältere Version		Version vom 17. März 2011, 15:34 Uhr
Zeile 213:		Zeile 213:


	In der Tat, um das wait() anzuwenden sind wir gezwungen, einen der zwei Locks zu wählen, und demnach wird lediglich ein einziger der beiden Locks während des Wartens freigegeben. Im vorliegenden Fall verriegelt der Aufruf ~~methoden~~() gänzlich den lock1, und zwar so lange wie lock2.wait() nicht zu Ende gekommen ist.		In der Tat, um das wait() anzuwenden sind wir gezwungen, einen der zwei Locks zu wählen, und demnach wird lediglich ein einziger der beiden Locks während des Wartens freigegeben. Im vorliegenden Fall verriegelt der Aufruf methode() gänzlich den lock1, und zwar so lange wie lock2.wait() nicht zu Ende gekommen ist.

	== Das Paket java.util.concurrent.locks ==		== Das Paket java.util.concurrent.locks ==

EagleEye am 10. August 2008 um 21:39 Uhr

2008-08-10T21:39:35Z

AndreUhres: /* In der API 1.5 eingerichtete Lösungen */

2008-07-26T22:43:54Z

In der API 1.5 eingerichtete Lösungen

← Nächstältere Version		Version vom 26. Juli 2008, 22:43 Uhr
Zeile 318:		Zeile 318:
	<code=java>Executor executor = Executors.newSingleThreadExecutor () ;		<code=java>Executor executor = Executors.newSingleThreadExecutor () ;
	executor.execute ( new Runnable () {		executor.execute ( new Runnable () {
	~~Public~~ void run () {		public void run () {
	System.out.println ( "asynchroner Aufruf 1" ) ;		System.out.println ( "asynchroner Aufruf 1" ) ;
	}		}
	}) ;		}) ;
	executor.execute ( new Runnable () {		executor.execute ( new Runnable () {
	~~Public~~ void run () {		public void run () {
	System.out.println ( "asynchroner Aufruf 2" ) ;		System.out.println ( "asynchroner Aufruf 2" ) ;
	}		}
Zeile 332:		Zeile 332:

	Andere Werkzeuge sind ebenfalls verfügbar, konsultiere dazu bitte die Dokumentation.		Andere Werkzeuge sind ebenfalls verfügbar, konsultiere dazu bitte die Dokumentation.


	= Gegenseitiges Blockieren =		= Gegenseitiges Blockieren =

212.24.220.80: /* Das Paket java.util.concurrent.locks */

2008-04-03T09:35:20Z

Das Paket java.util.concurrent.locks

← Nächstältere Version		Version vom 3. April 2008, 09:35 Uhr
Zeile 107:		Zeile 107:
	== Das Paket java.util.concurrent.locks ==		== Das Paket java.util.concurrent.locks ==

	Eine andere Methode, um Locks zu verwirklichen, ist erstmals in Java 1.5. erschienen. Sie kann auf den ersten Blick schwieriger scheinen, aber sie ist ~~machvoller~~, da sie erlaubt, Sachen zu machen, die das Schlüsselwort '''synchronized''' nicht erlaubt (wir werden später darauf zurückkommen). Hier siehst du, wie sie zu benutzen ist:		Eine andere Methode, um Locks zu verwirklichen, ist erstmals in Java 1.5. erschienen. Sie kann auf den ersten Blick schwieriger scheinen, aber sie ist machtvoller, da sie erlaubt, Sachen zu machen, die das Schlüsselwort '''synchronized''' nicht erlaubt (wir werden später darauf zurückkommen). Hier siehst du, wie sie zu benutzen ist:

	<code=java> Lock l;		<code=java> Lock l;

212.24.220.80: /* Das Schlüsselwort synchronized */

2008-04-03T09:34:41Z

Das Schlüsselwort synchronized

← Nächstältere Version		Version vom 3. April 2008, 09:34 Uhr
Zeile 84:		Zeile 84:


	„einObjekt“ stellt ~~ein~~ Lock (Riegel) dar, welcher irgendein Java Objekt sein kann. Aber Vorsicht, es ist besser, Referenzen zu benutzen, die als „final“ deklariert wurden, um sicher zu sein, dass die Referenz auf das Objekt nicht geändert wird; in der Tat, der nachfolgende Code funktioniert nicht:		„einObjekt“ stellt einen Lock (Riegel) dar, welcher irgendein Java Objekt sein kann. Aber Vorsicht, es ist besser, Referenzen zu benutzen, die als „final“ deklariert wurden, um sicher zu sein, dass die Referenz auf das Objekt nicht geändert wird; in der Tat, der nachfolgende Code funktioniert nicht:

	<code=java>synchronized (meineListe) {		<code=java>synchronized (meineListe) {

AndreUhres: /* Das Paket java.util.concurrent.locks */

2008-03-15T03:21:20Z

Das Paket java.util.concurrent.locks

← Nächstältere Version		Version vom 15. März 2008, 03:21 Uhr
Zeile 217:		Zeile 217:
	== Das Paket java.util.concurrent.locks ==		== Das Paket java.util.concurrent.locks ==

	Die Lösung, die wir oben bereits gesehen haben, um den gegenseitigen Ausschluss unter Benutzung dieses Pakets zu verwirklichen, erlaubt es uns auch, über die Grenzen der Methoden der Object-Klasse hinauszugehen. Dabei besteht die Grundidee darin, nur '''~~ein~~''' Lock zu benutzen, aber mit mehreren Bedingungsvariablen, auf denen wir die Operationen durchführen können, die ähnlich sind wie wait() und notify().		Die Lösung, die wir oben bereits gesehen haben, um den gegenseitigen Ausschluss unter Benutzung dieses Pakets zu verwirklichen, erlaubt es uns auch, über die Grenzen der Methoden der Object-Klasse hinauszugehen. Dabei besteht die Grundidee darin, nur '''einen''' Lock zu benutzen, aber mit mehreren Bedingungsvariablen, auf denen wir die Operationen durchführen können, die ähnlich sind wie wait() und notify().

	<code=java>class EineKlasse {		<code=java>class EineKlasse {

AndreUhres: /* Benutzung */

2008-03-15T03:05:14Z

Benutzung

← Nächstältere Version		Version vom 15. März 2008, 03:05 Uhr
Zeile 135:		Zeile 135:
	=== Benutzung ===		=== Benutzung ===

	Die grundlegendste Art der Synchronisation zwischen mehreren Java Threads ist die Benutzung der Methoden wait(), notify() und eventuell notifyAll(), die in der Object-Klasse definiert sind. Um ihre Funktionsweise zu begreifen, vervollständigen unser Beispiel von soeben:		Die grundlegendste Art der Synchronisation zwischen mehreren Java Threads ist die Benutzung der Methoden wait(), notify() und eventuell notifyAll(), die in der Object-Klasse definiert sind. Um ihre Funktionsweise zu begreifen, vervollständigen wir unser Beispiel von soeben:

	<code=java>class StringList {		<code=java>class StringList {

AndreUhres: /* Das Paket java.util.concurrent.locks */

2008-03-15T03:02:58Z

Das Paket java.util.concurrent.locks

← Nächstältere Version		Version vom 15. März 2008, 03:02 Uhr
Zeile 115:		Zeile 115:
	l.lock();		l.lock();
	try {		try {
	//kritischer Abschnitt		//kritischer Abschnitt
	} finally {		} finally {
	l.unlock();		l.unlock();

AndreUhres: /* Gegenseitiger Ausschluss von kritischen Abschnitten */

2008-03-15T02:58:10Z

Gegenseitiger Ausschluss von kritischen Abschnitten

← Nächstältere Version		Version vom 15. März 2008, 02:58 Uhr
Zeile 59:		Zeile 59:
	list[index] = s; //(a1) list[index] = s; //(b1)		list[index] = s; //(a1) list[index] = s; //(b1)
	index++; //(a2) index++; //(b2)		index++; //(a2) index++; //(b2)
	}</code=java> }		}</code=java>


Zeile 125:		Zeile 125:

	Jedoch, wenn du einen dermaßen einfachen gegenseitigen Ausschluss machen willst, wie jene der hier vorgestellten Beispiele, rate ich dir '''synchronized''' zu benutzen und die Methode des Pakets java.util.concurrent.locks für recht besondere Fälle zu reservieren, die wir später sehen werden.		Jedoch, wenn du einen dermaßen einfachen gegenseitigen Ausschluss machen willst, wie jene der hier vorgestellten Beispiele, rate ich dir '''synchronized''' zu benutzen und die Methode des Pakets java.util.concurrent.locks für recht besondere Fälle zu reservieren, die wir später sehen werden.


	= Gemeinsame Synchronisation =		= Gemeinsame Synchronisation =

← Nächstältere Version		Version vom 10. August 2008, 21:39 Uhr
Zeile 7:		Zeile 7:
	= Einführung =		= Einführung =

	Die Synchronisation ist ein wesentliches Element, sobald mehrere ~~Threads~~ benutzt werden (das heißt in fast allen Anwendungen). In der Tat, ohne Synchronisation ist es unmöglich, eine robuste Anwendung zu entwickeln, die funktioniert, ungeachtet der Verflechtungen ihrer Threads.		Die Synchronisation ist ein wesentliches Element, sobald mehrere [[Thread]]s benutzt werden (das heißt in fast allen Anwendungen). In der Tat, ohne Synchronisation ist es unmöglich, eine robuste Anwendung zu entwickeln, die funktioniert, ungeachtet der Verflechtungen ihrer Threads.


Zeile 18:		Zeile 18:
	'''Mehrere Synchronisationsprobleme stellen sich hier:'''		'''Mehrere Synchronisationsprobleme stellen sich hier:'''

	# Mehrere Empfänger können nicht gleichzeitig eine Arbeit in die Warteschlange der Arbeiten ablegen, andernfalls wären diese Aufträge in demselben Kasten;		# Mehrere Empfänger können nicht gleichzeitig eine Arbeit in die [[Warteschlange]] der Arbeiten ablegen, andernfalls wären diese Aufträge in demselben Kasten;
	# Wenn die Warteschlange der Arbeiten voll ist, müssen die Empfänger darauf warten, dass ein Kasten frei wird, um eine neue Arbeit abzulegen;		# Wenn die Warteschlange der Arbeiten voll ist, müssen die Empfänger darauf warten, dass ein Kasten frei wird, um eine neue Arbeit abzulegen;
	# Mehrere Arbeiter können nicht jeder gleichzeitig eine Arbeit nehmen, andernfalls hätten sie dieselbe Arbeit zu erledigen;		# Mehrere Arbeiter können nicht jeder gleichzeitig eine Arbeit nehmen, andernfalls hätten sie dieselbe Arbeit zu erledigen;
Zeile 54:		Zeile 54:


	Dieses Programm, wie du es geraten haben wirst, erlaubt es, eine Liste von Strings zu verwalten, indem es ein Array benutzt.		Dieses [[Programm]], wie du es geraten haben wirst, erlaubt es, eine Liste von Strings zu verwalten, indem es ein [[Array]] benutzt.

	<code=java>void add ( String s ) { void add ( String s ) {		<code=java>void add ( String s ) { void add ( String s ) {
Zeile 68:		Zeile 68:
	*(a1) (b1) (b2) (a2) ist eine mögliche, aber zusammenhanglose Ausführung: die Tabelle enthält die durch T1 hinzugefügte Zeichenfolge nicht, und ein Kasten der Liste ist leer.		*(a1) (b1) (b2) (a2) ist eine mögliche, aber zusammenhanglose Ausführung: die Tabelle enthält die durch T1 hinzugefügte Zeichenfolge nicht, und ein Kasten der Liste ist leer.

	Mehrere andere Ausführungen können zu anderen Ergebnissen führen, von denen einige zusammenhanglos sind. Dieses rückläufige Problem kann durch den gegenseitigen Ausschluss gelöst werden. Die Funktion add(String) wird '''kritischer Abschnitt''' genannt. Mehrere abhängige kritische Abschnitte dürfen ihren Code nie gleichzeitig ausführen (durch mehrere verschiedene Threads): man sagt, dass sie in gegenseitigem Ausschluss sind. Im vorhergehenden Beispiel ist add(String) in gegenseitigem Ausschluss mit sich selbst, aber man kann sich sicher gut vorstellen, dass sie auch in gegenseitigem Ausschluss mit der Funktion „remove“ ist...		Mehrere andere Ausführungen können zu anderen Ergebnissen führen, von denen einige zusammenhanglos sind. Dieses rückläufige Problem kann durch den gegenseitigen Ausschluss gelöst werden. Die Funktion add([[String]]) wird '''kritischer Abschnitt''' genannt. Mehrere abhängige kritische Abschnitte dürfen ihren Code nie gleichzeitig ausführen (durch mehrere verschiedene Threads): man sagt, dass sie in gegenseitigem Ausschluss sind. Im vorhergehenden Beispiel ist add(String) in gegenseitigem Ausschluss mit sich selbst, aber man kann sich sicher gut vorstellen, dass sie auch in gegenseitigem Ausschluss mit der Funktion „remove“ ist...

	Um den gegenseitigen Ausschluss zu schaffen, muss man '''Locks''' (Riegel) benutzen. Wenn ein Thread auf einen kritischen Abschnitt zukommt, verlangt er den Lock. Wenn er ihn erhält, kann er den Code ausführen. Wenn er ihn nicht erhält, weil ein anderer Thread ihn bereits genommen hat, dann wird er blockiert, indem er darauf wartet, ihn zu erhalten. Es ist möglich, eine potentiell unendliche Anzahl von Locks zu benutzen, und demnach präzise gegenseitige Ausschlüsse zu verwirklichen: zum Beispiel muss a() in gegenseitigem Ausschluss mit sich selbst und mit b() sein, während c() in gegenseitigem Ausschluss mit sich selbst und mit d()sein muss, aber nicht mit a() und b()...		Um den gegenseitigen Ausschluss zu schaffen, muss man '''Locks''' (Riegel) benutzen. Wenn ein Thread auf einen kritischen Abschnitt zukommt, verlangt er den Lock. Wenn er ihn erhält, kann er den Code ausführen. Wenn er ihn nicht erhält, weil ein anderer Thread ihn bereits genommen hat, dann wird er blockiert, indem er darauf wartet, ihn zu erhalten. Es ist möglich, eine potentiell unendliche Anzahl von Locks zu benutzen, und demnach präzise gegenseitige Ausschlüsse zu verwirklichen: zum Beispiel muss a() in gegenseitigem Ausschluss mit sich selbst und mit b() sein, während c() in gegenseitigem Ausschluss mit sich selbst und mit d()sein muss, aber nicht mit a() und b()...
Zeile 77:		Zeile 77:
	== Das Schlüsselwort synchronized ==		== Das Schlüsselwort synchronized ==

	Um dies in Java zu verwirklichen, besteht die einfachste Methode darin, das Schlüsselwort '''synchronized''' zu benutzen. Hier sieht man, wie es benutzt wird:		Um dies in [[Java]] zu verwirklichen, besteht die einfachste Methode darin, das Schlüsselwort '''synchronized''' zu benutzen. Hier sieht man, wie es benutzt wird:

	<code=java>synchronized ( einObjekt ) {		<code=java>synchronized ( einObjekt ) {