den Code synchronizen

[Generic1]

Hallo,

ich habe mir mal ein Testbeispiel gemacht, in dem mein Problem dargestellt ist, ich habe 2 Klassen, in einer Klasse befindet sich eine List, die im EDT- Thread in einer Endlosschleife verwendet wird, und in der 2. Klasse wird dieselbe Liste auch verwendet. Meine Frage wäre nun, wo muss ich auf die Liste überall synchronisieren, auch in der set- Methode usw.

PS: bzw. was mir noch einfällt, blöde frage aber ich stell sie mal, muss man auf die Referenz der Liste synchronisieren (sprich die Referenz muss immer gleichbleiben) oder auf die Liste?

package threadtest1;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {

    private final List<String> list;

    public Main() {
        list = new ArrayList<String>();
        ListIteration li = new ListIteration();
        li.start();
        while(true) {
            synchronized(list) {
                for(int i = 0; i < 5; i++) {
                    list.add("Hallo" + i);
                    }
                for(Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
                    String next = iterator.next();
                    System.out.println("im EDT");
                    }
                li.setList(list);
                }
            }
        }

    public static void main(String[] args) {
        new Main();
        }
}
class ListIteration extends Thread {

    private List<String> list;

    public ListIteration() {
        list = new ArrayList<String>();
        }

    public void setList(List<String> list) {
        this.list = list;
        }

    @Override
    public void run() {
        while(true) {
            synchronized(list) {
                for(Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
                    final String next = iterator.next();
                    System.out.println("im Thread");
                    iterator.remove();
                    }
                }
            }
        }
    }

 

[SlaterB]

synchronisiert wird auf das Objekt, egal über welche Variable angesprochen,
und nur beim Durchlaufen/ add/ remove usw. ist es nötig,
das Objekt kann währenddessen ruhig herumgereicht werden (set-Methode),
das bewirkt zunächst nichts außer der Gefahr, dass irgendein anderer Code damit in Berührung kommt, der dann doch 'Durchlaufen/ add/ remove' macht,
Collections.sort(list) ist als Aufruf nicht schlimm, in der Gesamtaktion dagegen schon

wenn du im Thread in der for-Schleife drin bist, dann wird die bis zum Ende auf die alte Liste durchlaufen,
auch wenn zwischendurch per set() eine neue gesetzt wird,
der Thread beginnt ja mit einer eigenen separaten Liste, wenn auch leer

im ungünstigsten Fall bezieht sich der synchronized(list) {} Aufruf aus Zeile 48 auf die alte erste Liste,
dann wird der Thread unterbrochen, set() von main setzt eine neue Liste und die Schleife im Thread (49) arbeitet unsynchronisiert auf der neuen Liste,
insofern kann das set() also wirklich gefährlich sein,
in set() auf die alte Liste zu synchronisieren wäre möglich, oder z.B. auf das Thread-Objekt, und in der run-Methode auch (synchronized(this))
bei Methoden kann man einfach
> public synchronized void setList(..)
schreiben


der Fehler hier ließe sich aber auch vermeiden, wenn die run-Methode in jedem Schleifendurchlauf eine lokale Variable anlegt:

while {
   List l = this.list
   synchronized(l) {
      for (l) {

so wird garantiert auf die richtige Liste synchronisiert und es bleibt nur noch der Punkt, das this.list zwischenzeitlich eine andere Liste wird

 

[Generic1]

Was ich in diesem Zusammenhang noch interessant finde ist, das ein synchronized Wrapper in diesem Fall gar nichts bewirkt, wahrscheinlich weil ich von 2 verschiedenen Referenzen auf die Liste zugreife.

package threadtest1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Main {

    private final List<String> list;

    public Main() {
        list = Collections.synchronizedList(new ArrayList<String>());
        ListIteration li = new ListIteration();
        li.start();
        while(true) {
          //  synchronized(list) {
                for(int i = 0; i < 5; i++) {
                    list.add("Hallo" + i);
                    }
                for(Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
                    String next = iterator.next();
                    System.out.println("im EDT");
                    }
                li.setList(list);
                }
           // }
        }

    public static void main(String[] args) {
        new Main();
        }
}

class ListIteration extends Thread {

    private List<String> list;

    public ListIteration() {
        list = new ArrayList<String>();
        }

    public void setList(List<String> list) {
        this.list = Collections.synchronizedList(list);
        }

    @Override
    public void run() {
        while(true) {
            final List l = this.list;
            //synchronized(l) {
                for(Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
                    final String next = iterator.next();
                    System.out.println("im Thread");
                    iterator.remove();
                    }
              //  }
            }
        }
    }

 

[SlaterB]

bei setList() rufst du Collections.synchronizedList() auf eine evtl. bereits derart synchronisierte Liste auf,
das kann schon Probleme machen, wäre genauer zu untersuchen,

bei Iteratoren bringt Collections.synchronizedList() aber gar nichts,
es ist wichtig, dass beim gesamten Iterator-Durchlauf die Liste nicht geändert wird,
wie sollte das sichergestellt werden ohne einen eigenen Block?

beim Erstellen des Iterators kann kaum ein zeitlich unbegrenzter Schutz aufgebaut werden
(was nur mit synchronized-Schlüsselwort eh nicht geht, da muss die schließende Klammer immer in 'Blickweite' sein),
wann wäre der je beendet, soll man nach dem Durchlauf iteratorFertig() aufrufen und die Liste so wieder freigeben?
das macht ja keiner

nur einzelne Methodenaufrufe wie add/ remove werden duch Collections.synchronizedList() synchronisiert
und wirkungsvoll blockiert wenn jemand anders bereits eine derartige Methode aufruft
oder für einen Komplettdurchlauf einen normalen synchronized(list)-Block verwendet

 

[Landei]

Oder probiere mal CopyOnWriteArrayList (Java Platform SE 6)