Java Threads, gemeinsamer Speicher

[Tawarien]

Hey, ich steck grad ein klein wenig fest.
Wenn ich in Java meherer Threads laufen hab,
wie mach ichs da am einfachsten, dass alle Threads auf einen gemeinsamen Speicher zugreifen können,
in meinem Beispiel auf ne Hashap?
Also diese auslesen/hinzufügen/verändern können.

Danke schonmal.

 

[SE]

In dem du eine eigene Klasse von Thread ableitest und deren Konstruktor eine this-Referenz vom erzeuger mitgibst. In die Caller-Klasse dann diese drei Methoden public *oder protected falls selbes package* und vorallem SYNCHRONIZED ... und gut is.

 

[Tawarien]

Klappt soweit, danke dir!

 

[Technoblade]

Ein alternative dazu die Methoden selber synchronized zu machen ist die Methode getSynchronizedMap der Klasse Collection zu verwenden. Die erstellt einem aus einer bereits bestehnden Map eine neue die daraufausgeöegt ist von mehreren Threads gleichzeitig verwendet zu werden.

 

[genodeftest]

Oder du nimmst die ConcurrencyHashMap aus dem Paket java.util.concurrent

 

[SE]

Ich hänge mich mal aus dem Fenster mit noch ner Lösung : ThreadPool
Falls nicht korrigiert mich bitte =)

 

[genodeftest]

ThreadPool taugt mehr dazu, eine große Anzahl an Aufgaben/Threads zu verwalten, aber weniger für die Verwaltung der Daten.

 

[Tawarien]

Hm, irgendwie will das noch nicht ganz so, wie ich mir das denke ... ich hab noch etwas hin und her programmiert, aber trotzdem.

Hier mal der Code, vielleicht kann mich jemand auf ne Idee bringen oder sieht, ob ich (was wohl wahrscheinlich ist) nen gedanklichen Fehler hab.

import java.util.HashMap;

public class Test
{
	   public static void main( String[] args )
	   {
		  HashMap<Integer, String> map = new HashMap<Integer, String>();
		  int count = 1000;
		  for(int i = 1; i <= count; i++)
			  map.put(i, Integer.toString(i));
			  
		   
	      (new Object( 1, map )).start();
	      (new Object( 2, map )).start();
	      (new Object( 3, map )).start();
	   }
}

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

class Object extends Thread
{
	   int meineThreadNum;
	   int i = 1;
	   Map map = null;

	   Object( int meineThreadNum, HashMap<Integer, String> map )
	   {
	      this.meineThreadNum = meineThreadNum;
	      this.map = Collections.synchronizedMap(map);
	   }

	   @Override
	   public synchronized void run()
	   {
		   //synchronized(map) {
		   while(!map.isEmpty()) {
			   System.out.println("Thread " + meineThreadNum + ": " + map.get(i));
			   map.remove(i);
			   i++;
			   try { Thread.sleep( 1 ); } catch( InterruptedException ex ) {}
		   //}
		   }
	   }
}

 

[twagi]

Hi,

Du erzeugst Dir in deiner Klasse Object jedesmal eine neue synchronisierte Map. Das bedeutet, dass jeder Thread sein eigenes Lock besitzt und die anderen Threads nicht vom Zugriff ausgeschlossen werden.

Probier mal die synchronisierte Map in der Klasse Test zu erzeugen und an die Threads zu übergeben. Dann sollten alle Threads mit dem gleichen Lock arbeiten und sich gegenseitig ausschließen.

Gruß twagi

 

[Technoblade]

Jup, twagi hat recht. Aber deswegen antworte ich hier nicht. Du solltest dir am besten auch noch einen anderen Namen für die Thread-Klasse überlegen. Denn eine Klasse Namens Object gibt es schon. Object ist wohl die wichtigste Klasse in der Java Standard-API. Es bereitet hier zwar keine Probleme und vermutlich in den meisten anderen Fällen auch nicht. Dennoch ist es von den Konventionen her angemessener keine weiteren Klassen Object zu nennen, da dies leicht zu Verwirrungen führen kann.