Hi!

Wir sollen einen Scheduler-Thread bauen, der alle Rechenthreads aufnimmt und jedem eine bestimmte Zeit rechnen lässt, dann den nächsten usw...
Also im Round Robin Verfahren.

Das Problem ist nur, dass ich nicht genau weiß, wie ich das mit wait und notify mache.
Ich hab mir das so gedacht, dass der Scheduler-Thread ein array mit allen Threads hat, und dann einen Thread startet. Wenn dieser genug gerechnet hat schickt der SChed-Thread ihm ein Signal, damit er aufhört, und dem nächsten ein Signal, damit er weiterrechnet. Also zum aufhören bring man ihn wohl wenn der Thread wait() ausführt. Aber ich hab das prinzip nicht so ganz verstanden.

Führe ich dann in dem zu stoppenden Thread scheduler.wait aus, oder this.wait?

Ich hab es so gemacht:

Alle Threads liegen dem Scheduler ungestartet in einem Array vor.
Wird der Sched. gestartet, dann startet er alle Threads in einer schleife.
Die Threads führen alle zu anfang wait aus.

Das komische ist nur, dass das Programm abbricht, obwohl der Scheduler-Thread in einer endlosschleife läuft. Es gibt nicht eine Ausgabe.

Wenn ich jedoch die waits aus den Rechenthreads entferne läuft alles ganz normal, nur eben nicht gescheduled

Kann mir da jemand weiterhelfen?

MfG, Ybbus

[Murray]

So ganz verstehe ich den Ansatz noch nicht - in der VM gibt es ja bereits einen Scheduler, der den verschiedenen Threads Rechenzeit zuteilt. Dieses Verhalten musst Du wohl irgendwie "aushebeln"...

Kannst Du Deinen Code posten (mit Code-Tags)?

Naja, wir sollen eben einen eigenen Scheduler simulieren.
Und das soll mit wait und notify geschehen.

Ich hab halt gedacht, dass man jeden Thread auf wait stellt, bis er ein notify bekommt. Wenn der nächste Thread dran ist macht der aktuelle wieder ein wait und der nächste beginnt wegen dem notify. Mein Code ist leider nicht richtig und bringt wohl nich so viel.

Also:

Scheduler Thread, der alle Rechenthreads in einem Array vorliegen hat.
Problem: Man soll mit Round Robin-Verfahren jedem Thread eine Zeitspanne zusichern, in der er rechnen darf. Das ganze soll mit wait und notify bewerkstelligt werden.

[Murray]

Scheduler Thread, der alle Rechenthreads in einem Array vorliegen hat.
Problem: Man soll mit Round Robin-Verfahren jedem Thread eine Zeitspanne zusichern, in der er rechnen darf. Das ganze soll mit wait und notify bewerkstelligt werden.

M.E. erfordert das zumindest kooperative Rechenthreads ("kooperatives Multitasking" vs. "Präemptives Multitasking"); die Rechenthreads müssen also von sich aus hinreichend oft dem Scheduler Gelegenheit geben, einen anderen Thread laufen zu lassen. Dazu müssen die Thread selbst wait() aufrufen.

Also, das kann der Scheduler ja bestimmen, wann sie wait aufrufen sollen.
Es geht mir nur darum, wie ich wait und notify überhaupt sinnvoll benutze.

[Murray]

Das könnte so aussehen:

/**
 * Simple test case for Thread-scheduling with wait/notify
 *
 */
public class Test {


	/**
	 * The Scheduler. It controls an array of worker-Threads
	 */
	public class Scheduler implements Runnable {
		Worker[] Workers;
		int Idx = -1;
		int TimeSlice;
	
		public Scheduler( int numThreads, int timeSlice) {
	
			TimeSlice = timeSlice;
			Workers = new Worker[ numThreads];
			for ( int i=0; i<Workers.length; i++) Workers[i] = new Worker();
		
		}
		
		public void start() {
			(new Thread( this)).start();
		}
		
		public void activateNext() {
			
			//--- Idx is -1 on first invocation (in this case there is no active thread yet)
			if ( Idx >= 0) Workers[Idx].passivate();
			
			//--- round-robin
			Idx++;
			if ( Idx >= Workers.length) Idx = 0; 
			
		    Workers[Idx].activate();	    	
		}
		
		public void run() {
			try {
				//--- endless loop
				while ( true) {
					activateNext();
					Thread.sleep( TimeSlice);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	
	}
	/**
	 * The Worker-Thread. It does some kind of calculation in a very time-consuming way
	 */
	public class Worker implements Runnable {
	
		public Object Lock = new Object();		
		private boolean Go;
		private long Data;
		
		public Worker() {
			//--- start the thread but don't start calulating yet
			Go = false;
			(new Thread( this)).start();
		}
		
		/**
		 * Make this Worker the active one -> start calculating
		 */
		public void activate() {
			try {
				synchronized( Lock) {
					Go = true;
					Lock.notify();
				}
			} catch ( Exception e) {
				e.printStackTrace();
			}
		}
		
		/**
		 * Temporarily stop calculating (Thread is still running!)
		*/
		public void passivate() {
			Go = false;
		}
		
		public void run() {
		
			try {
				//--- endless loop
				while ( true) {
					synchronized( Lock) {
		 			//--- cooperative multitasking: we have to periodically check if the Scheduler wants us to stop
						while( Go) {
		 		 	Data = Data + 1;
		 		 	System.out.println( this + ":" + Thread.currentThread() + " Data=" + Data);
						}
		 			//--- we have been passivated (Go = false) and now have to wait until we are activated again
						Lock.wait();
					}
				}
			} catch ( Exception e) {
				e.printStackTrace();
			}
		}
	}

	
	public Test() {
	
		Scheduler s = new Scheduler( 4, 1000);
		s.start();
	}
	
	public static void main( String[] args) {
		new Test();
	}
	
}