Threads programmierung

[Gast]

Moin,

ich habe untere Methode, welche manchmal nur einmal , manchmal aber auch 2 mal oder öfter nacheinander aufgerufen wird,
leider hab ich das Problem, wenn ich diese Methode öfter aufrufe, der Speicher ziemlich ansteigt und irgendwann das Programm mit Java Heap Space OutOfMemory abstürzt,
Ich habe jetzt keine Ahnung, wie so das manchmal funkt und dann so was auftritt,
Ich erzeuge unten ja Threads (je nachdem, wie oft ich die Methode aufrufe), welche mir die Arbeit verrichten sollen

Was mach ich da falsch,
Vielen Dank,

public void getListAndDrawOnTracePanel(final TracePanelLineAttributes tracePanelLineAttributes) {        
            Thread thread = new Thread() {
                @Override
                public void run() {
                    writeBean.setZeitstempel1(tracePanelLineAttributes.getFrom());
                    writeBean.setZeitstempel2(tracePanelLineAttributes.getUntil());
                    writeBean.setTabelle(tracePanelLineAttributes.getTableName());
                    List<DBWertReadBean> valueList = null;
                    try {
                        valueList = (List<DBWertReadBean>) AppSQLConfig.getSqlMapInstance().queryForList("getWerteVonProzetur", writeBean);                        
                        }
                    catch (SQLException ex) {
                        System.out.println("Ausnahme in der Klasse TracePanelListReader in der Methode run: " + ex);
                        }
                    tracePanelLineAttributes.getTracePanel().createDatasetAndYAxis("Name" + AStart.anzahlLines++, "Einheit", valueList, tracePanelLineAttributes.getColor());
                    if (tracePanelLineAttributes.isSetUpperAndLowerAxisBeforeZoom())
                        tracePanelLineAttributes.getTracePanel().setUpperAndLowerAxisBeforeZoom();
                    }
                };
            thread.start();            
        }

 

[Murray]

In einer VM können nicht beliebig viele Threads gleichzeitig laufen. Wie sieht das denn in Deinem Fall auf? Kommt es vor, dass hier viele Threads schnell hintereinander gestartet werden (und zwar so schnell, dass sie schneller neu erzeugt werden, als sie verarbeitet werden können)?

 

[Guest]

So rufe ich die Methode oben auf, die Threads werden also schon ziemlich schnell erzeugt.
Kann ich da was dagegen machen?

for (int i = 0; i < tracePanel.getLineNumbers(); i++) {
                tracePanelLineAttributes = new TracePanelLineAttributes();
TracePanelLineAttributes tracePanelLineAttributes = createLineAttributes(tracePanel, from, new Timestamp(e.getSelectedDate().getTime().getTime()), tables[tableCounter++], getRandomColor(), true)
                tracePanelListReader.getListAndDrawOnTracePanel(tracePanelLineAttributes );
                }

 

[Guest]

PS: es handelt sich so um maximal 5- 7 Threads, welche über die for- Schleife erzeugt werden,

 

[thisismyname]

Moin,

ich habe untere Methode, welche manchmal nur einmal , manchmal aber auch 2 mal oder öfter nacheinander aufgerufen wird,
leider hab ich das Problem, wenn ich diese Methode öfter aufrufe, der Speicher ziemlich ansteigt und irgendwann das Programm mit Java Heap Space OutOfMemory abstürzt,
Ich habe jetzt keine Ahnung, wie so das manchmal funkt und dann so was auftritt,
Ich erzeuge unten ja Threads (je nachdem, wie oft ich die Methode aufrufe), welche mir die Arbeit verrichten sollen

Was mach ich da falsch,
Vielen Dank,

public void getListAndDrawOnTracePanel(final TracePanelLineAttributes tracePanelLineAttributes) {        
            Thread thread = new Thread() {
                @Override
                public void run() {
                    writeBean.setZeitstempel1(tracePanelLineAttributes.getFrom());
                    writeBean.setZeitstempel2(tracePanelLineAttributes.getUntil());
                    writeBean.setTabelle(tracePanelLineAttributes.getTableName());
                    List<DBWertReadBean> valueList = null;
                    try {
                        valueList = (List<DBWertReadBean>) AppSQLConfig.getSqlMapInstance().queryForList("getWerteVonProzetur", writeBean);                        
                        }
                    catch (SQLException ex) {
                        System.out.println("Ausnahme in der Klasse TracePanelListReader in der Methode run: " + ex);
                        }
                    tracePanelLineAttributes.getTracePanel().createDatasetAndYAxis("Name" + AStart.anzahlLines++, "Einheit", valueList, tracePanelLineAttributes.getColor());
                    if (tracePanelLineAttributes.isSetUpperAndLowerAxisBeforeZoom())
                        tracePanelLineAttributes.getTracePanel().setUpperAndLowerAxisBeforeZoom();
                    }
                };
            thread.start();            
        }

Probier doch mal das ganze in einer Richtigen Klassendefinition festzumachen und nicht so anonym... evtl liegts ja daran. Ich habs so noch nie probiert und kenn es nur mit Klassen die von Thread erben...

public void getListAndDrawOnTracePanel(final TracePanelLineAttributes tracePanelLineAttributes) {        
            Thread thread = new superKlasse();

            superKlasse.start();
         
public void superKlasse extends Thread{
                public void run() {
                    writeBean.setZeitstempel1(tracePanelLineAttributes.getFrom());
                    writeBean.setZeitstempel2(tracePanelLineAttributes.getUntil());
                    writeBean.setTabelle(tracePanelLineAttributes.getTableName());
                    List<DBWertReadBean> valueList = null;
                    try {
                        valueList = (List<DBWertReadBean>) AppSQLConfig.getSqlMapInstance().queryForList("getWerteVonProzetur", writeBean);                        
                        }
                    catch (SQLException ex) {
                        System.out.println("Ausnahme in der Klasse TracePanelListReader in der Methode run: " + ex);
                        }
                    tracePanelLineAttributes.getTracePanel().createDatasetAndYAxis("Name" + AStart.anzahlLines++, "Einheit", valueList, tracePanelLineAttributes.getColor());
                    if (tracePanelLineAttributes.isSetUpperAndLowerAxisBeforeZoom())
                        tracePanelLineAttributes.getTracePanel().setUpperAndLowerAxisBeforeZoom();
                    }
                }
   }
        }

Nur so als POC, weis nicht genau ob das jetzt schon genauso passt.

greetz

 

[Murray]

PS: es handelt sich so um maximal 5- 7 Threads, welche über die for- Schleife erzeugt werden,

Das sollte normalerweise noch passen.

Hantieren die Thread mit sehr großen Ergebnissen für die einzelnen Queries? Dann ist der Heap vielleicht wirklich einfach zu klein eingestellt. In dem Fall könntest Du der Java-VM per -Xmx-Option mehr Heap gönnen. Wenn es allerdings doch irgendwo ein Memory-Leak gibt, dann wird der Fehler immer noch auftreten - nur eben später.

 

[mahe]

In einer VM können nicht beliebig viele Threads gleichzeitig laufen. (...)

Wo liegt denn da die Grenze?
In einem Bereich wo man sich darum sorgen muss oder irgendwo in den Sternen?

 

[Murray]

Wo liegt denn da die Grenze?
In einem Bereich wo man sich darum sorgen muss oder irgendwo in den Sternen?

Das ist schwer zu sagen. Ein limitierender Faktor ist der Stack, der für jeden einzelnen Stack reserviert werden muss. Diesen Wert man per -Xss festlegen, aber eben nur für alle Thread gleichzeitig. Wenn man also - z.B. wegen hoher Rekursiontiefen - irgendwo einen großen Stack braucht, dann passen insgesamt weniger Threads in den Speicher.

Ausprobieren kann man das mit einem kleinen Testprogramm:

public class ThreadTest {
	
	
	public static void main( String[] args) throws Exception {
		
		final Object o = new Object();
		int num = 0;
		while ( true) {
			num++;
			new Thread( new Runnable() {
				public void run() {
					 synchronized( o) {
					 	try {
					 		o.wait();
					 	} catch ( Exception e) {
					 		e.printStackTrace();
					 	}
					 }
				}
			}).start();
			System.out.println( num + ". Thread gestartet"); System.out.flush();
		}
			
	}
}

Mit den Default-Einstellungen werden bei mir über 5000 Threads gestartet, bevor es knallt. Sorge ich per -Xss10M für einen größeren Stack, so knallt es bei knapp 200. Interessanterweise scheint auch das Erhöhen des maximalen Heaps per -Xmx die maximale Thread-Anzahl zu verringern.

Allerdings stellt sich natürlich die Frage, was heutige Rechner überhaupt mit Dutzenden von Threads anfangen sollen - selbst mit mehreren Kernen und Hyperthreading ist die Anzahl der effektiv parallel zu verarbeitenden Tasks üblicherweise deutlich kleiner.

Insofern könnte man vielleicht sagen: sofern man nicht die Stackgröße auf enorme Werte setzen muss, braucht man derzeit keine Sorgen zu haben, dass man weniger Threads anlegen kann, als der Rechner parallel zu verarbeiten in der Lage ist. Verwendet man aber das Thread-Konzept da, wo man eigentlich eine Event-Queue bräuchte (wenn man also z.B. für jedes GUI-Event einen neuen Thread startet, um den Event-Dispatcher-Thread zu entlasten), dann könnte man durchaus vor die Wand laufen.