Threads Minimale und maximale Anzahl.

[archer1000]

Gegeben ist dieses Code:

public class MyThread extends Thread{
	private double zahl;
	private static double staticZahl;

	public MyThread(double zahl){
	   this.zahl = zahl;
	}
	
	
	public void run(){
	  while (staticZahl >= 0) {
	    staticZahl = zahl;
/*		try {
		  sleep(1000);
		} catch (InterruptedException e) {
		  e.printStackTrace();
		}
/*
		System.out.println(staticZahl);
	    }
	}
	

	public static void main(String[] args) {
	  MyThread.staticZahl = 2;
	  MyThread thread1 = new MyThread(-1.5);
	  MyThread thread2 = new MyThread(0.5);
	  MyThread thread3 = new MyThread(1);

	  thread1.start();
	  thread2.start();
	  thread3.start();
	}

a) Handelt es sich um ein deterministisches Programm? Begründen Sie ihre Wahl!
b) Geben Sie die minimale und die maximale Anzahl an ausgeführten println-Befehlen an und begründen Sie ihre Wahl.
c) Geben Sie eine Ausgabe der ersten 10 Zeilen des Programms auf der Kommandozeile an.
d) Was würde passieren wenn man den auskommentierten Block wieder mit ins Programm einzieht?

Könnt ihr beim Lösen helfen. Was ich gemacht habe.
a) Es handelt sich um ein nicht deterministisches Programm, aber warum kann ich nicht antworten
b) Ich verstehe auch nicht warum unterschiedliche Anzahl von println commands ausgeführt werden sollen.
c) Es sollte eigentlich meiner Meinung nach verschieden sein, da das Programm nicht deterministisch ist.
d) Was macht eigentlich auskommentierte Block?

 

[sommerferien]

lool was bist du denn für einer? hast du keine sommerferien oder wie kommts dass du das forum mit deinen hausaufgaben überschwemmst?

 

[archer1000]

lool was bist du denn für einer? hast du keine sommerferien oder wie kommts dass du das forum mit deinen hausaufgaben überschwemmst?

Jaa, Ich habe halt 8 Aufgaben die ich gerne gelöst haben möchte.

 

[hüteüberhüte]

Also das Programm wird in irgendeiner Reihenfolge -1.5, 0.5 oder 1 ausgeben.

zu a) Nein, weil das Programm (soweit ich noch weiß) nicht zu jeden Zeitpunkt in einen eindeutigen Folgezustand übergeht
b) Das Programm wird anhalten, [STRIKE]wenn es -1.5 ausgegeben hat[/STRIKE] wenn staticZahl den Wert -1.5 besitzt und alle Threads bereits ihre Zuweisungsanweisung durchgeführt haben. Wann das passiert, lässt sich nicht vorhersagen
c) Dafür müsste man es ausführen...
d) IMHO nichts anderes, außer vielleicht, dass zwischen Zuweisung an staticZahl und der Ausgabe sich staticZahl öfter ändern könnte

just my 2 cents, ich teste das jetzt mal

 

[kaschik]

Eventuell hat der TO das Programm falsch abgeschrieben, denn so richtig ergibt das keinen Sinn für mich. 😕

MyThread.staticZahl := 2
thread1.zahl := -1.5
thread2.zahl := 0.5
thread3.zahl := 1

thread1 startet, geht in die while-Schleife, da 2 >= 0, setzt dort MyThread.staticZahl := -1.5 und gibt -1.5 aus.
thread2 startet, geht nicht in die while-Schleife, da -1.5 >= 0 nicht erfüllt ist.
thread3 startet, geht nicht in die while-Schleife, da -1.5 >= 0 ebenfalls nicht erfüllt ist.

Ein kurzer Test bestätigt die Vermutung: es erscheint nur -1.5 am Bildschirm und das wars.

Der auskommentierte Block macht nichts anderes als eine Sekunde zu pausieren.

 

[hüteüberhüte]

thread1 startet, geht in die while-Schleife, da 2 >= 0, setzt dort MyThread.staticZahl := -1.5 und gibt -1.5 aus.
thread2 startet, geht nicht in die while-Schleife, da -1.5 >= 0 nicht erfüllt ist.
thread3 startet, geht nicht in die while-Schleife, da -1.5 >= 0 ebenfalls nicht erfüllt ist.

Das war auch meine Beobachtung. Habe

thread1.start();

mal nach hinten verschoben. Dann wird ohne Warten 0.5, 1, -1.5 ausgegeben, und mit Warten 3x -1.5

Nicht so ein ideales Beispiel. Imho ist eine Zuweisung auch keine atomare Operation, so dass staticZahl auch irgendeinen Wert annehmen könnte

 

[hüteüberhüte]

War das so vielleicht?:

public class MyThread extends Thread {

    private static double staticZahl;
    private double zahl;

    public MyThread(double zahl) {
        this.zahl = zahl;
    }

    public void run() {
        while (staticZahl >= 0) {
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            staticZahl = zahl;
            System.out.println(staticZahl);
        }
    }

    public static void main(String[] args) {
        MyThread.staticZahl = 2; // hat keine Auswirkungen
        MyThread thread1 = new MyThread(-1.5);
        MyThread thread2 = new MyThread(0.5);
        MyThread thread3 = new MyThread(1);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

Dann kann es nämlich sein, dass MyThread(-1.5) irgendwann fertig ist, während die anderen noch laufen

 

[archer1000]

War das so vielleicht?:

public class MyThread extends Thread {

    private static double staticZahl;
    private double zahl;

    public MyThread(double zahl) {
        this.zahl = zahl;
    }

    public void run() {
        while (staticZahl >= 0) {
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            staticZahl = zahl;
            System.out.println(staticZahl);
        }
    }

    public static void main(String[] args) {
        MyThread.staticZahl = 2; // hat keine Auswirkungen
        MyThread thread1 = new MyThread(-1.5);
        MyThread thread2 = new MyThread(0.5);
        MyThread thread3 = new MyThread(1);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

Dann kann es nämlich sein, dass MyThread(-1.5) irgendwann fertig ist, während die anderen noch laufen

Nie, ich die auskommentierte Stelle iwie Fehler gemacht.

public class MyThread extends Thread{
	private double zahl;
	private static double staticZahl;

	public MyThread(double zahl){
	   this.zahl = zahl;
	}
	
	
	public void run(){
	  while (staticZahl >= 0) {
	    staticZahl = zahl;
/*		try {
		  sleep(1000);
		} catch (InterruptedException e) {
		  e.printStackTrace();
		}
*/
		System.out.println(staticZahl);
	    }
	}
	

	public static void main(String[] args) {
	  MyThread.staticZahl = 2;
	  MyThread thread1 = new MyThread(-1.5);
	  MyThread thread2 = new MyThread(0.5);
	  MyThread thread3 = new MyThread(1);

	  thread1.start();
	  thread2.start();
	  thread3.start();
	}
}

 

[archer1000]

Diese auskommentierte Stelle soll zuerts nicht dran kommen. Ich glaube ich verstehe warum die minimale Anzahl der Println 1 ist. Verstehe ich aber nicht wie ich die maximale Anzahl vorhersagen kann.

 

[kaschik]

Mea culpa! Ich revidiere meine Aussage, denn

thread1.start();
      thread2.start();
      thread3.start();

heißt NICHT, dass thread1 tatsächlich vor thread2 bzw. thread3 startet. Wenn man das Programm oft genug schnell hintereinander ausführt, kommt man auf unterschiedliche Reihenfolgen und Ausgaben.

Jetzt ergeben die Fragen auch mehr Sinn:
a) Das Programm ist nicht deterministisch, da man nicht so ohne weiteres sagen kann, welcher der drei Threads zuerst startet.
b) Minimal ein println, nämlich -1.5, und maximal unbestimmbar viele. (ob das wirlich so "unbestimmbar" ist, weiß ich nicht, aber im Moment habe ich keine Idee, um das nach oben abzuschätzen)
c) 1.0 1.0 1.0 1.0 1.0 1.0 0.5 -1.5 -1.5 oder was auch immer.
d) Egal welcher der drei Threads nun zuerst startet, durch das Warten ist sichergestellt, dass staticZahl = -1.5 ist. Denn nach thread3 kann niemand mehr die while-Schleife betreten und staticZahl verändern. Die Ausgabe sind dann ein bis mehrere -1.5.

 

[hüteüberhüte]

@kaschik: Klingt einleuchtend. Würde auf jeden Fall sagen, du hast die Fragen besser beantwortet...

 

[archer1000]

Wie kann es sein, dass -1.5 mehr mals erscheinen. Wenn ich es raten würde 1 mal, da erst staticZahl 2 und dann auf -1.5 gestellt. und das ist kleiner Null und while beendet, erscheint keine weitere -1.5 mehr. Aber die Tatsache, was auf meinem Rechner läuft widerspricht das. Ich verstehe nicht.

 

[hüteüberhüte]

Wie kann es sein, dass -1.5 mehr mals erscheinen.

[JAVA=12] staticZahl = zahl;
/* try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
*/
System.out.println(staticZahl);[/code]

Wenn zwischen der Zuweisung und der Ausgabe die anderen Threads warten - so also die Ausgabe beeinflusst wird

Aber wie gesagt, es lässt sich nicht sagen, wann welcher Thread aktiv ist

 

[archer1000]

Gentlemen, ich muss mich entschuldigen. Ich habe beim Eintippen tatsächlich einen kleinen, aber fatalen Fehler gemacht. Die Code lautet so:

staticZahl -= zahl;

public class MyThread extends Thread{
	private double zahl;
	private static double staticZahl;

	public MyThread(double zahl){
	   this.zahl = zahl;
	}
	
	
	public void run(){
	  while (staticZahl >= 0) {
	    staticZahl -= zahl;
/*		try {
		  sleep(1000);
		} catch (InterruptedException e) {
		  e.printStackTrace();
		}
*/
		System.out.println(staticZahl);
	    }
	}
	

	public static void main(String[] args) {
	  MyThread.staticZahl = 2;
	  MyThread thread1 = new MyThread(-1.5);
	  MyThread thread2 = new MyThread(0.5);
	  MyThread thread3 = new MyThread(1);

	  thread1.start();
	  thread2.start();
	  thread3.start();
	}
}



a)	(1 Punkte) Handelt es sich um ein deterministisches Programm? Begründen Sie ihre Wahl!
b)	(2 Punkte) Geben Sie die minimale und die maximale Anzahl an ausgeführten println-Befehlen an und begründen Sie ihre Wahl.
c)	(1 Punkte) Geben Sie eine Ausgabe der ersten 10 Zeilen des  Programms auf der Kommandozeile an.
d)	(1 Punkte) Was würde passieren wenn man den auskommentierten Block wieder mit ins Programm einzieht?

 

[archer1000]

jetzt macht es auch viel mehr Sinn. Ich glaube ich habe es verstanden.

Bei a ist die Antwort nicht deterministisch.
b) Minimal kann es 3 ausgeführte println() Befehle sein, da im ideal Fall thread3 am Anfang 3 mal hintereinander durchgeführt wird. Alle andere threads verlänhgern nur den Lauf. Aber bei der maximale Zahl bin ich nicht sicher. Ich glaube man kann es nicht so festlegen. Mir ist überhaupt nicht klar warum das Programm immer beendet. Es ist ja schliesslich -1.5 kann mehr staticZahl vergrössern als die anderen beiden.
c) Ein beiSpiel: Ich habe es laufen lassen und geguck.
1.5
2.0
3.5
5.0
6.5
8.0
9.5
11.0
12.5
13.5
15.0
16.5
18.0
19.5
21.0
22.5
24.0
25.5


Mir ist nicht klar, wie es von 1.5 auf 2 am Anfang kommt. 0.5 wird nirgendwo addiert. Addiert wird nur immer 1.5 und abgezogen werden 1 und 0.5. Oder habe ich unrecht?

Und ich kann Teil d nicht. Könnt ihr bitte erklären, warum es unendlich dann das Programm läuft. wenn man den Kommentar mit ins code einbezieht?

 

[langhaar!]

Das Programm ist deterministisch. Schon aus dem einfachen Grund, dass Nichtdeterminismus nicht real existiert; es ist ein theoretisches Konstrukt.

Dass man die Berechnung des Programmes nicht vorhersagen kann, liegt daran, dass nicht alle Daten bekannt sind. Theoretisch lassen sich diese ermitteln. So ist z.B. auch ein Zufallsgenerator ein deterministisches Programm.

 

[buzz!dev]

@langhaar!: Stammt diese Sichtweise aus einer Informatik- oder einer Philosophievorlesung?

 

[archer1000]

Ich glaube, er sagt, Würfel werfen ist deterministisch. Theoretisch streng genommen ja, aber in dem Fall geht nicht darum. Das Programm ist nicht deterministisch oder?

 

[Marco13]

Das Programm ist deterministisch. Schon aus dem einfachen Grund, dass Nichtdeterminismus nicht real existiert; es ist ein theoretisches Konstrukt.

Geek And Poke: The Geek&Poke Philosophy Special 😀

 

[buzz!dev]

Ich glaube, er sagt, Würfel werfen ist deterministisch. Theoretisch streng genommen ja, aber in dem Fall geht nicht darum. Das Programm ist nicht deterministisch oder?

Korrekt, das Programm ist nicht deterministisch - zumindest nach der in der Informatik üblichen Definition von Determinismus.

 

[hüteüberhüte]

Gentlemen, ich muss mich entschuldigen. Ich habe beim Eintippen tatsächlich einen kleinen, aber fatalen Fehler gemacht. Die Code lautet so:

staticZahl -= zahl;

Damit ergeben die Aufgaben (und vor allem

MyThread.staticZahl = 2;

) auch einen Sinn. a) Nicht deterministisch, weil die Threads in zufälliger Reihenfolge ausgeführt werden. Über "zufällig" lässt sich allerdings streiten
b) Minimal wohl 3 Ausgaben, maximal wohl unendlich, denn 1,5-0,5-1 ergibt 0
c) Programm starten...
d) Vermutlich würde öfter 3-mal das Gleiche ausgegeben werden, denn die Threads werden vor der Ausgabe angehalten

 

[archer1000]

Damit ergeben die Aufgaben (und vor allem

MyThread.staticZahl = 2;

) auch einen Sinn. a) Nicht deterministisch, weil die Threads in zufälliger Reihenfolge ausgeführt werden. Über "zufällig" lässt sich allerdings streiten
b) Minimal wohl 3 Ausgaben, maximal wohl unendlich, denn 1,5-0,5-1 ergibt 0
c) Programm starten...
d) Vermutlich würde öfter 3-mal das Gleiche ausgegeben werden, denn die Threads werden vor der Ausgabe angehalten

Danke dir. Deine Beiträge sind immer umfassend. Könntest du mir erklären wie es von 1.5 auf 2 am Anfang kommt.Bei wir wurde beim Programmablauf einmal 1.5 und dann 2 ausgedrückt. Das kann ich halt nicht nachvollziehen. Wie 1.5 ZUstande kommt ist klar: von 2 wurde 0.5 abgezogen und ausgedrückt. 0.5 wird nirgendwo addiert. Addiert wird nur immer 1.5 und abgezogen werden 1 und 0.5. Meine Meinung nach soll in der nächste Zeile stehen eine dieser drei Ergebnisse: entweder
1.5 - 0.5 = 1 oder
1.5 -1 = 0.5 oder
1.5 + 1.5 = 3.

Oder habe ich unrecht?

 

[hüteüberhüte]

Könntest du mir erklären wie es von 1.5 auf 2 am Anfang kommt.Bei wir wurde beim Programmablauf einmal 1.5 und dann 2 ausgedrückt.

2 => 0,5 wird abgezogen und 1,5 wird ausgegeben => 1 wird abgezogen und der Thread wird angehalten => 1,5 wird addiert und 2 wird ausgegeben.

Nach Ausführung der Subtraktion und vor Ausführung der Ausgabeanweisung kann der auszuführende Thread gewechselt werden - oder (wenn sie wirklich parallel laufen) ein anderer Thread könnte schneller sein

Das Wechseln der Threads geschieht immer zufällig. Sicher ist nur, dass ein angehaltener Thread an derselben Stelle fortgesetzt wird

 

[Empire Phoenix]

Für alle die arbeiten und geldverdienen nicht deterministisch, für trollende philosophiestudenten (wie verirren die sich in dieses forum?) anscheinend nicht 😛

 

[hüteüberhüte]

[OT]

Danke dir. Deine Beiträge sind immer umfassend.

Bin schon etwas länger dabei. Wie lange, weiß ich jetzt nicht. Aber leider gibt's immer viel Zoff :noe:[/OT]

BTT: Determinismus (Algorithmus) ? Wikipedia

Zu jedem Zeitpunkt ist der nachfolgende Abarbeitungsschritt des Algorithmus eindeutig festgelegt. [...] Im Umkehrschluss können bei einem nichtdeterministischen Algorithmus nicht reproduzierbare und undefinierte Zustände auftreten.

Und dann noch: Deterministischer endlicher Automat ? Wikipedia

DEA [...] der unter Eingabe eines Zeichens seines Eingabealphabetes (den möglichen Eingaben) von einem Zustand, in dem er sich befindet, in einen eindeutig bestimmten Folgezustand wechselt.

Mathematische Definition von Determinismus habe ich jetzt nicht gefunden, müsste ich in ein paar Folien kramen, aber im Prinzip besagt die auch nur, dass für jeden Zustand und jede Eingabe eindeutig festgelegt ist, in welchen Folgezustand übergegangen wird

Für jeden Thread (oder Threads), die gerade ausgeführt werden, lässt sich aber nicht sagen, welcher als nächstes ausgeführt wird

 

[langhaar!]

Für alle die arbeiten und geldverdienen nicht deterministisch, für trollende philosophiestudenten (wie verirren die sich in dieses forum?) anscheinend nicht 😛

Es gibt auch Leute, die arbeiten und trotzdem einen soliden theoretischen Hintergrund haben.
Ich habe Informatik an einer sehr stark theoretisch ausgerichteten Uni studiert und den Begriff des Nichtdeterminismus abstrakter und strenger kennengelernt.

Wiki gibt mir recht
Nichtdeterminismus ? Wikipedia

Nichtdeterministische Maschinen sind theoretische Modelle und offensichtlich nicht praktisch realisierbar.

Letztlich ist es eine einfache Definitionsfrage und wer den Nichtdeterminismus abweichend definiert, bekommt abweichende Ergebnisse.
Wobei mich schon interessiert, ob mir jemand eine anerkannte Definition geben kann, die meiner Auffassung widerspricht.

Für jeden Thread (oder Threads), die gerade ausgeführt werden, lässt sich aber nicht sagen, welcher als nächstes ausgeführt wird

Weil dir die notwendigen Daten fehlen; aber nicht prinzipiell.

 

[hüteüberhüte]

Nur mal angenommen, die Threads werden wirklich parallel ausgeführt, dann kann es immer Schwankungen geben und zwei Threads werden nie exakt gleich schnell laufen

Was stört dich so daran? a) Nicht deterministisch ist auf jeden Fall die richtige Antwort. Das haben jetzt schon so viele hier bestätigt

 

[hubbaBubba]

Weil dir die notwendigen Daten fehlen; aber nicht prinzipiell.

Natürlich nicht prinzipiell. Aber aus Sicht des Programmierers und des Anweders fehlen diese Daten und sind auch nicht ohne Weiteres eruierbar. In diesem Kontext also nicht deterministisch. Nicht mehr und nicht weniger wurde hier gefragt.

 

[Marco13]

Für alle die arbeiten und geldverdienen nicht deterministisch, für trollende philosophiestudenten (wie verirren die sich in dieses forum?) anscheinend nicht 😛

Soweit ich weiß wird auch in einem Philosophiestudium am Anfang (in welcher Tiefe auch immer, aber immerhin) ein bißchen mit der wirkich formalen Aussagenlogik rumhantiert. Ich finde ja, dass das irgendwo in der 9. Klasse schon mal angesprochen werden sollte. Das würde vielleicht zu etwas Demut führen, und zu Zurückhaltung mit der Aussage: "Is' doch logisch!!!" 😉