Synchronisierung von Threads

[P@u1]

Hallo zusammen,

beim Arbeiten mit thraeds bin ich auf ein paar Fragen gestoßen:
1. nehmen wir an ich habe einen integer der mit dem wert 5 initialisiert wird.
Dann nehme ich einen neuen thread, der den wert der variable auf 100 setzt.
Ungefähr gleichzeitig liest ein anderer thread den wert der variablen.
Ist dann garantiert, dass entweder 5 oder 100 rauskommt, oder kann auch ein ganz anderer wert herauskommen, falls mitten beim bit setzen unterbrochen wurde (falls das denn geht)?

2. Hat es irgendeinen Sinn zu synchronisieren durch locks oder volatile oder so, bei einem boolean?
Ich habe mir dazu folgendes überlegt:
erstmal ohne locks o.ä.:
thread 1 setzt einen boolean um, thread 2 liest ungefähr gleichzeitig, dann kommt entweder true oder false heraus, kann bedes passieren

Dann das selbe mit lock:
Thread 1 holt einen lock und setzt den boolean um und öffnet den lock danach, ungefähr gleichzeitig versucht thread 2 den lock zu setzen und auszulesen und den lock dann zu öffnen.
Also wurde die Problematik von wer zuerst liest/schreibt nur auf wer zuerst den lock holt verschoben, wie ich das sehe bringt in diesem fall ein lock nichts.
Wie seht ihr das?

3. Wird bei Verwendung von volatile "optimiert"?
Ich meine zum Beispiel folgendes:

public volatile ArrayList<Integer> al;
//hat irgendnen Inhalt jetzt
for(int i : al)
{
   //tu irgendwas
}

Wir dort der lock zwischem jeden schleifendurchlauf verlassen und neu geholt, oder wird das so gemacht, dass der lock für alle durchläufe geschlossen bleibt?

So, das wars erstmal.
Vielen Dank schonmal für eure Antworten.

 

[tagedieb]

1. Wenn du atomare Operationen verwendest wirst du entweder 5 oder 100 erhalten. Eine Zuweisung ist atomar.
Sowas wie: i = i+1; ist nicht atomar, sondern 2 Operationen read und write.

2. Wenn du dich mit Threads nicht sogut auskennst empfehle ich dir synchronized zu verwenden, ansonsten kann es sehr leicht kompliziert werden.
Atomare Operationen auf Variablen koennen mitteln Volatile geloest werden. Nichtatomare Operationen sollten synchronisiert werden.

3. Volatile optimiert den Code
Jeder Thread hat seinen eigenen Heap. Erst bei Synchronized wird die Variable von Thread ins Shared Memory synchronisiert.
Volatile haelt die Variable direkt im Shared Memory. Wenn du weder Volatile oder Synchronized verwendest kann es sein, dass ein Thread eine Variable aendert, der andere Thread diese aber nicht 'sehen' kann, da nicht synchronisiert wurde.

 

[Empire Phoenix]

Zu zweitens mit lock, wenn du eine bestimmte reiehenfolge sicherstellen willst könnte man Semaphoren nehmen, die einfach dafür sorgen das der zweite erst nach ende des ersten in den block kommen kann.
Bischen runterscrollen sind ganz gute Vorlesungs folien dazu die können dir evtl weiterhelfen.

KR & KM Research Group: Praktische Informatik II FSS10

 

[tagedieb]

Multithreading ist nicht so einfach und da kann man schnell was falsch machen.
Am Anfang wuerde ich mich einfach auf den Gebrauch von synchronized beschraenken.

Wenn du Zeit hast kannst du dich auch hier ins Thema einlesen Concurrency in Practice.


Wenn du nur eine Liste synchronisieren musst kannst du auch einfach eine synchronizedList erzeugen:

List<Integer> synchronizedList = java.util.Collections.synchronizedList(a1);

Somit ist der Zugriff auf die Liste threadsafe. Die Integer Klasse ist immutable, also auch threadsafe.
Benutzt du mutierbare Objekte muss der Zugriff auf diese Objekte auch threadsafe gemacht werden.

 

[bygones]

1. Wenn du atomare Operationen verwendest wirst du entweder 5 oder 100 erhalten. Eine Zuweisung ist atomar.
Sowas wie: i = i+1; ist nicht atomar, sondern 2 Operationen read und write.

sind doch 3.... lesen, erhöhen, schreiben.

Atomare Operationen auf Variablen koennen mitteln Volatile geloest werden. Nichtatomare Operationen sollten synchronisiert werden.

bzw AtomInteger oder so nutzen...

 

[P@u1]

Nochmal zum sichergehen:
Gucken wir uns folgendes Beispiel an:
Wir haben zwei erzeugte ArrayList-Objekte, nennen wir sie al1 und al2.
Außerdem haben wir eine public variable, die eine ArrayList ist, also eine Referenz auf eine Arraylist speichert.
Jetzt haben wir einen thread, der den wert dieser variablen immer zwischen den beiden ArrayList objekten hin und her tauscht.
Ein anderer Thread liest diese variable ab und zu, wir benutzen keine synchronisierung, wenn dann nur volatile.
Ist dann sichergestellt, dass der lese-Thread immer entweder eine Referenz auf al1 oder al2 ausliest, oder kann es passieren, dass eine ungültige Referenz ausgelesen wird, weil der schreibthread mitten im schreiben der refernz unterbrochen wurde?

Ich vermute stark, dass bei der Zuweisung nicht unterbrochen werden kann.
Allerdings frage ich mich dann, warum es die Klasse AtomicReference gibt, die eine Methode set hat, die wenn meine Vermutung zutrifft dann doch überflüssig wäre, oder?

 

[tagedieb]

Wenn du nur die Methoden .get() und .set(V) von AtomicReference verwendest kannst du

volatile

verwenden.
Aber die AtomicReference Klasse bietet ja auch noch complexere Methoden an.