Synchronisierte Listen. ein Graus

[Guvnor]

Hallo!

Ich verzweifel hier noch fast. Ich habe ein kleines Programm, wo von mehreren Threads auf die gleiche Liste zugegriffen wird. Dadurch fliegt dauernd eine ConcurrentModificationException, weil z.B. der eine Thread gerade über die Liste iteriert und der andere ein Element hinzufügen will.

Dann habe ich es mit der synchronizedList versucht, also auf die folgende Art und Weise:

list = Collections.synchronizedList(list);

Das hat deutlich besser funktioniert, aber bei vielen "Anfragen", also vor allem vielen Hinzufügungen, ist auch das gescheitert. Mit der gleichen Exception wie davor schon.

Danach hab ich mir meine eigene List gemacht, indem ich einfach von der ArrayList abgeleitet hab und die get, add, remove und clear-Methoden überschrieben hab. Laut JavaDoc funktioniert die Iteration ebenfalls durch die get-Methode, dadurch sollte es ja reichen, die gerade eben erwähnten Methoden zu überschreiben. Aber auch das half nix. Der Vollständigkeit halber hier trotzdem mal mein Code, obwohl ich eigentlich der Meinung bin, daß der funktionieren müßte:

public class SyncList<T> extends ArrayList<T>
{
	private boolean mutex = false;
	private static final long serialVersionUID = 1L;

	
	public T get(int i)
	{
		while(mutex);
		
		synchronized(this)
		{
			mutex = true;
			T temp = super.get(i);
			mutex = false;
			
			return temp;
		}
	}
	
	
	public boolean add(T o)
	{
		while(mutex);
		
		synchronized(this)
		{
			mutex = true;
			boolean result = super.add(o);
			mutex = false;
			
			return result;
		}
	}
	
	
	public boolean remove(Object o)
	{
		while(mutex);
		
		synchronized(this)
		{
			mutex = true;
			boolean result = super.remove(o);
			mutex = false;
			
			return result;
		}
	}
	
	
	public void clear()
	{
		while (mutex);
		
		synchronized(this)
		{
			mutex = true;
			super.clear();
			mutex = false;
		}
	}
}

Kann mir vielleicht doch noch einer helfen? Für was ist ein Collections.synchronizedList() da, wenn es keine synchronisierte Liste zurückgibt? Oder ist die JVM zu langsam für eine erfolgreiche Synchronisation? Oder muß ich doppelt und dreifach synchronisieren?

Danke schonmal im Voraus,
Guvnor

 

[SnooP]

Du musst auf jeden Fall vermeiden mit Hilfe eines Iterators über die Liste zu iterieren und gleichzeitig diese Liste zu verändern... der Iterator wird dadurch sofort ungültig und schmeißt die beobachtete Exception...
Andere Möglichkeiten: Du nutzt nicht den Iterator sondern durchläufst mit get-Methoden die Liste... - hast aber dann evtl. auch Probleme, synchronisiert muss es in jedem Fall ablaufen...
Oder aber du speicherst alle Zugriffe auf die Liste in einer zweiten Liste zwischen (add-List, remove-List) und machst am Ende der Änderungen - in einem stabilen Zustand - ein commit, indem du ein addAll bzw. removeAll über deine Zwischenlisten machst...

 

[SlaterB]

wozu schreibst du jeweils
while(mutex);
?
wenn mehrere Threads drauf zugreifen wollen, dann arbeiten alle mit 100%, statt auf den synchronized-Zugriff zu WARTEN,
lasse doch die Arbeit weg und die Threads wieder warten, dazu ist das synchronized doch da?

und dann kannst du gleich
public synchronized boolean remove(Object o)
{
...
schreiben an Stelle deiner Konstruktion, sieht viel schöner aus,

-----------

übrigens ist so eine Schleife auch nicht sicher,
wenn ein Thread fertig ist, können (theoretisch) zwei andere Threads (oder ein anderer und der gleiche nochmal)
die while-Schleife überspringen (da mutex false ist) und dann zusammen vor dem synchronized stehen,
deine Abfrage hilft also (thoretisch) gar nicht, aber synchronized ist natürlich sicher

 

[Pulvertoastman]

Oder aber:
http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/Semaphore.html

 

[Guvnor]

@ SlaterB: Du hast Recht, ich hab das dann auch geändert und die Methoden direkt synchronized gemacht. Aber auch das half nicht.

Nun habe ich einen völlig anderen Ansatz. Ich habe eine Queue, der ich Objekte adden kann und von der ich auch getten kann. Beim getten wird das Objekt aber direkt wieder removed. Somit iteriere ich nicht über die Liste, sondern hol mir in jedem Schleifendurchlauf innerhalb meines Threads einfach immer das älteste Objekt und arbeite damit. Dann wird es removed und erst im nächsten Durchlauf kommt das nächste dran.

In meinem Anwendungsfall paßt das perfekt, somit kann ich nun auf das Iterieren verzichten

Trotzdem vielen Dank für eure Antworten, auch wenn ich jetzt natürlich eine ganz andere Lösung verwende