Threads StackOverflow

[kaetzacoatl]

Hallo,
nur eine Frage aus reinem Interesse:
Wenn ich folgen Code ausführe bekomme
ich jedesmal eine andere Anzahl an
Methodenaufrufe, wenn ich keinen
eigenen Thread erzeuge ist sie immer
gleich.

public static void main(String[] args) {
		new Thread(Thread.currentThread().getThreadGroup(), new Runnable() {
			public void run() {
				long start = System.nanoTime();
				try {
					a();
				} catch (Error e) {
					long time = System.nanoTime() - start;
					System.out.println(calls);
				}
			}
		}, "!", 10000L).start();

	}

Warum bleibt die ausgabe gleich
und was hat sie mit "100000L"
zu tun?
Ich weiß, dass man damit die
Methodenaufrufe erhöhen kann,
aber wenn ich die Zahl erhöhe
und wenn ich sie senke erhöht
sich die Zahl der Methodenaufrufe.

Schonmal Danke!

 

[bERt0r]

Da wäre es vielleicht interessant zu wissen was a() macht um nur irgendwie dein Vorhaben zu verstehen.

 

[kaetzacoatl]

	private static void a() {
		calls++;
		a();
	}

Das wichtigste vergessen

 

[Bernd Hohmann]

Ughgxle....

Du spielst da etwas mit dem Feuer und dem, was der Stack so gerade hergibt.

Threads haben ihren eigenen Stack und bei Deinem rekursiven Aufruf von "a()" hängt das vom OS ab wie die Threads verteilt werden, wie sie ausgeführt werden und wann es letztendlich knallt.

Schon wieder so ein Beispiel, wo Threads nicht-deterministisch sind.

Bernd

 

[kaetzacoatl]

Aber warum ist es dann immer
gleich, wenn ich keinen Thread
erzeuge, sondern alles direkt
in der Main aufrufe?

 

[Bernd Hohmann]

Aber warum ist es dann immer
gleich, wenn ich keinen Thread
erzeuge, sondern alles direkt
in der Main aufrufe?

Äh.. wie sieht denn die Variante ohne Thread aus? Und vorallem: welches OS und welches Java nutzt Du?

Bernd

 

[Bernd Hohmann]

Ich hab mich jetzt mal zum Thema "Thread-Stacksize" (dein '10000L'-Parameter) eingelesen.

Wenn ich die Doku recht verstehe, ist die hier übergebene Größe des Stacks ein wohlwollender Hinweis an die VM sowie das Betriebssystem (sofern native OS-Threads verwendet werden), wieviel des Gesamtstacks der VM sich dieser Thread greifen darf. Dieser Parameter kann je nach VM und/oder mal so oder so interpretiert - oder auch ganz ignoriert werden.

Zitat: The details of the relationship between the value of the stackSize parameter and the maximum recursion depth and concurrency level are platform-dependent. On some platforms, the value of the stackSize parameter may have no effect whatsoever..

Wenn ich die Vorgabe des Stacks weglasse, gehen die Rekursionen von ~790 auf ~12600 hoch - was daran liegen mag, dass der Default-Stack bei mir vermutlich 512kb gross ist und Deine 10.000 halt nur 10kb sind. Es scheint also irgendeine Untergrenze zu geben und auch eine Obergrenze, denn 1GB Stack bringen nicht mehr Rekursionen (16GB RAM hier).

Es scheint also so zu sein, dass bei Threads die angeforderte Menge an Stack im Verhältnis an freiem Stack aus einem Pool gezogen wird der nicht wirklich konstant ist - im Gegensatz zum "gewöhnlichen" Hauptprogramm wo die Nummer der Rekursionen konstant bleibt.

Bernd

 

[Ark]

Mal unabhängig von der bisherigen Diskussion: Die Variable

calls

sollte eventuell mit dem Schlüsselwort

volatile

markiert werden.

Ark

 

[Bernd Hohmann]

Mal unabhängig von der bisherigen Diskussion: Die Variable

calls

sollte eventuell mit dem Schlüsselwort

volatile

markiert werden.

War das nicht so, dass auch nicht-volatile Variablen am Ende des Threads und bei Exceptions "zwangssynchronisiert" wurden?

Ich habs mal ausprobiert: keine Änderung der Zahlenfolge.

Bernd

 

[kaetzacoatl]

Äh.. wie sieht denn die Variante ohne Thread aus? Und vorallem: welches OS und welches Java nutzt Du?

        public static void main(String[] args) {
		try {
			a();
		} catch (Error e) {
			System.out.println(calls + " calls.");
		}
	}

Java 7 32-Bit auf Windows 7

 

[kaetzacoatl]

Ich hab jetzt beide Möglichkeiten hintereinander
geschrieben und jetzt ist die anzahl der
aufrufe (summe beider varianten) immer 10030
also fast genau 10000.
Ich versteh jetzt nnoch weniger???:L

 

[SlaterB]

was genau ist die Frage/ das Thema in diesem Thread?
a() wird rekursiv aufgerufen, das geht nicht beliebig oft ineinander, während eine Schleife endlos laufen kann,

irgendwann ist Schluss, über ein paar Hundert oder noch weniger besser gar nicht kommen,
bei Tausenden kann man schon mit Überlastung/ Rauch aus PC rechnen,
irgendwann ist halt Schluss, ob nun 10.000 oder 10.030, ob von eigenen Thread oder main-Thread aus,
willst du da wirklich einzelne Unterschiede im Detail noch wissen?

 

[Bernd Hohmann]

was genau ist die Frage/ das Thema in diesem Thread?

Die Frage ist schon interessant: Wenn die Rekursion im Main-Thread läuft, ist die Anzahl bis zum Stackoverflov konstant. Läuft das über einen zusätzlichen Thread in der Main-ThreadGroup, variiert die Anzahl der Rekursionen - was mir in diesem simplen Beispiel etwas kömisch vorkommt.

Bernd