Thread Programmierung

[Guest]

Hallo,

ich habe an der Uni eine Aufgabe zur Thread-Programmierung erhalten, habe aber keine Ahnung wie ich das realisieren soll. Habe noch nie mit Threads in Java gearbeitet.
Folgende Aufgabe:

In der Vorlesung lernen Sie demnächst das Produzenten/Konsumenten-Problem kennen, bei dem ein
Produzent Objekte in einen Puffer einfügt und der Konsument diese ausliest. Im ersten Projekt soll
eine Variante dieses Problems betrachtet werden. Der Produzent schreibt in beliebiger Reihenfolge
die Werte 0...n − 1 in einen Puffer. Der Konsument darf Werte nur der Reihe nach aus dem Puffer
lesen. Um z.B. eine 5 aus dem Puffer lesen zu k¨onnen, muss er vorher bereits eine 4 gelesen haben,
usw.

Aufgabe 1.1
(a) Was fehlt den vorgegebenen Methodenköpfen in der Klasse Queue, damit verschiedene
Threads nebenläufig zugreifen können? Implementieren Sie die fehlenden Methodenrümpfe
der Klasse Queue.
(b) Implementieren Sie die run-Methode der Klasse ConsumerBusyWaiting so, dass sie die
Funktionalität des busy waiting erfüllt.
(Tipp: In Java kann ein Thread für eine gewisse Zeit deaktiviert werden, indem die sleep
Methode aufgerufen wird).
(c) Was sind die Nachteile von busy waiting? Welche Lösungen gibt es?

Aufgabe 1.2 Da busy waiting keine gute Lösung ist, soll das System nun durch Monitore realisiert
werden. Machen Sie sich mit der Benutzung von Monitoren in der Sprache Java vertraut.
(a) Erweitern Sie die Klasse ConsumerMonitor so, dass die Lösung ohne busy waiting auskommt.
(b) Welche Beschränkung gibt es in Java bezüglich der Realisierung von Monitoren?

public class TestQueue {

	public static void main(String[] args) {
		
		Queue q = new Queue();
		ConsumerBusyWaiting c = new ConsumerBusyWaiting(q, 10);
		Producer p = new Producer(q, 10);
		
		c.start();
		p.start();
		
	}

}

[code]public class Queue {

	public void read(int n) {

	}
	
	public int lowestValue() {

	}
	
	public boolean isNonEmpty() {

	}
	
	public void add(Integer n) {

	}

}

import java.util.Random;

public class Producer extends Thread {

	private final Queue q;
	private final int numInputValues;
	
	public Producer(Queue q, int numInputValues) {
		super();
		this.q = q;
		this.numInputValues = numInputValues;
	}

	public void run() {
		
		int[] inputValues = new int[numInputValues];
		
		for(int i = 0; i < numInputValues; i++)
			inputValues[i] = i; 

		// Generiert eine zufaellige Permutation
		Random rng = new Random();
		for(int j = 0; j < 100; j++) {
			int pos1 = rng.nextInt(numInputValues);
			int pos2 = rng.nextInt(numInputValues);
			
			int buf = inputValues[pos1];
			inputValues[pos1] = inputValues[pos2];
			inputValues[pos2] = buf;
		}
		
		for(int i = 0; i < numInputValues; i++) {
			System.out.println("Producer: Writing value " + inputValues[i]);
			q.add(inputValues[i]);
			
			try {
				sleep(10);
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}
		}
		System.out.println("Producer:
			All values successfully written to the queue");
	}
	
}

public class ConsumerBusyWaiting extends Thread {
	
	private final int numOutputValues;
	private final Queue q;
	
	public ConsumerBusyWaiting(Queue q, int numOutputValues) {
		super();
		this.numOutputValues = numOutputValues;
		this.q = q;
	}

	public void run() {

	}
}

public class ConsumerMonitor extends Thread {

}

[/code]

Wäre euch dankbar für eure Hilfe

 

[Guest]

Folgendes hatte ich mir mal überlegt:

import java.util.*;
import java.lang.*;

public class Queue {

    Vector v=new Vector();
    
	public synchronized void read(int n) {
            for(int i=0;i<v.size();i++){
                Integer temp=(Integer)v.elementAt(i);
                int help=temp.intValue();
                if(help==n){
                    v.removeElementAt(i);
                }
            }
        }
        
        public synchronized int lowestValue() {
            boolean gefunden=false;
            int help=11;
            for(int i=0;i<10;i++){
                for(int j=0;j<v.size();j++){
                    Integer temp =((Integer)v.elementAt(j));
                    help=temp.intValue();
                    if(help==i){
                       gefunden=true;
                       break;
                    }
                }
                if(gefunden)
                    break;
            }
            return(help);
	}
        
	public synchronized boolean isNonEmpty() {
            return (!v.isEmpty());
	}
	
	public synchronized void add(Integer n) {
            v.add(n);
	}

}

public class ConsumerBusyWaiting extends Thread {
	
	private final int numOutputValues;
	private final Queue q;
	
	public ConsumerBusyWaiting(Queue q, int numOutputValues) {
		super();
		this.numOutputValues = numOutputValues;
		this.q = q;
	}

	public void run() {
            boolean fertig=false;
            int zaehler=0;
            while(!fertig){
                int n=q.lowestValue();
                if(n==zaehler){
                    q.read(n);
                    System.out.println("Consument: Reading value "+ zaehler);
                    if(zaehler==9){
                        fertig=true;
                        System.out.println("Consument: All values successfully read from queue");
                    }
                    zaehler++;
                }
                else{
                    System.out.println("Consumer: busy waiting");
                }
                try{
                    sleep(10);
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
	}
}

[/code]

 

[LastUnicorn]

Wär schön, wenn du sagen würdest an welcher Stelle du genau hängst bzw was du wissen willst. Soooooooooo viel Spaß macht das Code lesen und Debugger spielen nämlich auch nicht.

 

[Guest]

Gut.
Die Sache mit dem Code ist so gut wie gegessen.
Was ich mir nicht erklären kann sind die Beschränkungen in Java bezüglich der Realisierung von Monitoren.
Was soll mir das sagen?
Gibt es da in Java Unterschiede zu anderen Sprachen?