Nichtdeterminismus in Java: warum?

[RoHo]

Hallo,

ich habe einen Algorithmus, ohne Threads, Zufallsvariablen o.Ä. trotzdem ist der Algorithmus nicht-deterministisch!
Woran kann das liegen?
Ich nutzte HashSets in for-Schleifen (for e: hashset<>){...} aber die Reihenfolge dieser Aktionen sollte keinen Unterschied machen!

Danke im Vorraus

RoHo

 

[Logaff]

Würdest du bitte Beispielcode posten? Weil meine Programme bestehen auch aus HashSets und for-each-Schleifen und sie deterministisch

 

[RoHo]

ok, der teil mit dem hashset, nicht über die namen wundern ;-)

Collections.sort(this.actionQueue); //, Collections.reverseOrder());

		// sort the bligs after hours of work left
		Collections.sort(this.workingBligs);

		// read the next time stamp at which something is happening, i.e.
		// a started action has finished and changes the current state
//		System.out.printf("T: %d ->", time);
		int nextTimeStep = actionQueue.get(0).getEndTimeStamp();
		// go to the next point in time in which something happens: the latest actions have finished
		this.time = nextTimeStep;
//		System.out.printf("%d\n", time);

		// get all actions which are scheduled at this point of time
		HashSet<Action> concurrentlyScheduledActions = new HashSet<Action>();
		for (int i = 0; i < this.actionQueue.size(); i++) {
			Action tempAction = this.actionQueue.get(i);
			if (tempAction.getEndTimeStamp() > nextTimeStep) {
				break;
			}
			concurrentlyScheduledActions.add(tempAction);
		}
for (Action a : concurrentlyScheduledActions) {
			if (a instanceof FindingPlonks) {
				this.findingPlonks("end");

			} else if (a instanceof MakingSpunks) {
				this.makingSpunkts("end");

			} else if (a instanceof ServicingBligs_2h) {
				this.servicingBligs_2h("end");

			} else if (a instanceof ServicingBligs_4h) {
				this.servicingBligs_4h("end");

			} else if (a instanceof ServicingPlonks) {
				// what to with the blig?
				Blig b = ((ServicingPlonks) a).getBlig();
				// this was the last working hour
				if (b.getHoursLeft() == 1) {
//					System.out.println("Remove blig");
					this.workingBligs.remove(b);
					this.noOfUsedBligs++;
				}
				// can be used again
				else {
//					System.out.println("REduce blig");
					b.reduceHoursByOne();
					this.workingBligs.add(b);
				}
				// activities performed independent of blig status
				this.servicingPlonks("end");

			} else {
				throw new IllegalArgumentException(String.format("Unknown type of action!: %s", a
						.getClass().toString()));
			}
			this.actionQueue.remove(a);
		}

folgende methoden werden aufgerufen:

	@Override
	public void makingSpunkts(String s) {
		s = s.toLowerCase();
		if (s.equals("start")) {
//			System.out.printf("Make Spunks: start\n");
			this.noOfSpunkees--;
			this.noOfWorkbenches--;
			this.actionQueue.add(new MakingSpunks(time));

		} else if (s.equals("end")) {
			// end the action (reschedule)
//			System.out.printf("Make Spunks: end\n");
			
			this.noOfSpunkees++;
			this.noOfWorkbenches++;

			this.noOfSpunks += 50;

		} else {
			String ss = String.format(
					"Action argument has to be \"start\" or \"end\"!\nBut is \"%s\"", s);
			throw new IllegalArgumentException(ss);
		}
	}

	@Override
	public void servicingBligs_2h(String s) {
		s = s.toLowerCase();
		if (s.equals("start")) {
			// start the action
//			System.out.printf("ServiceBligs(2h): start\n");
			this.noOfBligees -= 2;
			this.noOfWorkbenches--;

			this.noOfSpunks -= 40;
			this.noOfUsedBligs--;

			this.actionQueue.add(new ServicingBligs_2h(time));

		} else if (s.equals("end")) {
			// end the action (reschedule)
//			System.out.printf("ServiceBligs(2h): end\n");
			
			this.noOfBligees += 2;
			this.noOfWorkbenches++;

			this.workingBligs.add(new Blig());
		} else {
			String ss = String.format(
					"Action argument has to be \"start\" or \"end\"!\nBut is \"%s\"", s);
			throw new IllegalArgumentException(ss);
		}

	}

	@Override
	public void servicingBligs_4h(String s) {
		s = s.toLowerCase();
		if (s.equals("start")) {
			// start the action
//			System.out.printf("ServiceBligs(4h): start\n");
			this.noOfBligees -= 1;
			this.noOfWorkbenches--;

			this.noOfSpunks -= 20;
			this.noOfUsedBligs--;

			this.actionQueue.add(new ServicingBligs_4h(time));

		} else if (s.equals("end")) {
			// end the action (reschedule)
//			System.out.printf("ServiceBligs(4h): end\n");
			
			this.noOfBligees += 1;
			this.noOfWorkbenches++;

			this.workingBligs.add(new Blig());

		} else {
			String ss = String.format(
					"Action argument has to be \"start\" or \"end\"!\nBut is \"%s\"", s);
			throw new IllegalArgumentException(ss);
		}

	}

	@Override
	public void findingPlonks(String s) {
		s = s.toLowerCase();
		if (s.equals("start")) {
			// start the action
//			System.out.printf("findingPlonks: start\n");
			this.noOfPlinks--;

			this.noOfSpunks -= 10;

			this.actionQueue.add(new FindingPlonks(time));

		} else if (s.equals("end")) {
			// end the action (reschedule)
//			System.out.printf("findingPlonks: end\n");
			this.noOfPlinks++;

			this.noOfUnservicedPlonks += 10;

		} else {
			String ss = String.format(
					"Action argument has to be \"start\" or \"end\"!\nBut is \"%s\"", s);
			throw new IllegalArgumentException(ss);
		}

	}

	@Override
	public void servicingPlonks(String s) {
		s = s.toLowerCase();
		if (s.equals("start")) {
			// start the action
//			System.out.printf("ServicePlonks: start\n");
			
			this.noOfPlinks--;
			this.noOfWorkbenches--;
			Blig b = this.workingBligs.get(0);
			this.workingBligs.remove(0);
			// this.activeBligs.add(b);

			this.noOfSpunks -= 20;
			this.noOfUnservicedPlonks -= 5;

			this.actionQueue.add(new ServicingPlonks(time, b));

		} else if (s.equals("end")) {
			// end the action (reschedule)
//			System.out.printf("ServicePlonks: end\n");
			
			this.noOfPlinks++;
			this.noOfWorkbenches++;

			this.noOfServicedPlonks += 5;

		} else {
			String ss = String.format(
					"Action argument has to be \"start\" or \"end\"!\nBut is \"%s\"", s);
			throw new IllegalArgumentException(ss);
		}

	}

 

[RoHo]

habe ein vage Idee, *testen...*

Ok Fehler gefunden:
1.) Liste sortiert
2.) Hashset verwendet/durchlaufen --> Sortierung wieder hinfällig/zufällig --> nicht deterministisch

Trotzdem danke

 

[Lumaraf]

In HashSets und HashMaps ergibt sich die Ordnung bekanntlich anhand des hashcodes. Wenn man die Methode nicht implementiert ergibt sich der hashcode afaik aus der Speicheradresse, die natürlich bei jedem Durchlauf anders wäre.

 

[Spacerat]

[OT]

In HashSets und HashMaps ergibt sich die Ordnung bekanntlich anhand des hashcodes. Wenn man die Methode nicht implementiert ergibt sich der hashcode afaik aus der Speicheradresse, die natürlich bei jedem Durchlauf anders wäre.

Setz' Speicheradresse in Ganterpranken (Anführungszeichen), dann passt das. Eine Speicheradresse hat mehr als 32 Bit und wäre schon allein deswegen für 'nen Hashcode zu lang. Aber zumindest wird sie zur Berechnung eines solchen herangezogen. Ausserdem kann es auch passieren, dass dieser Hashcode auch mal den selben Wert wie in vorhergehenden Durchläufen hat.[/OT]
@TO: Sind unsere Definitionen von Determinismus die selben? Warum benötigst du zum Erzeugen von Pseudozufall etwas Deterministisches? Die Berechnung von Hashcodes ist deterministisch, nur die dazu verwendeten Daten sind's halt nicht. Deswegen sollte man für einen deterministischen Algo sollte man von Hashcodes Abstand nehmen.
[EDIT]Okay, das ist nur die halbe Wahrheit. -> du müsstest die "hashCode()"-Methode überschreiben, um einen solchen aus unveränderlichen Daten zu bekommen.[/EDIT]