Producer / Consumer mal anders.

[Mirko_Gast]

Hallo! Haben in der Schule folgede Aufgabe bekommen:
Simulieren Sie eine Warteschlange vor einem Skilift (Schlepplift)
mit folgenden Eigenschaften:
Alle 350 ms kommt ein neuer Skiliftbügel, der zwei Skifahrer befördern kann, wenn 2
Skifahrer da sind, die auf diesen Bügel warten. Der Skilift kann jeweils nur Paare von
Skifahrern befördern, d.h. einzelne Skifahrer müssen warten, bis sie einen Partner finden.
Von der Piste kommen zufällig Skifahrer alle 100 bis 300 ms zur Warteschlange hinzu.
Die Skifahrer von der Piste erhalten fortlaufende Nummern, um sie zu unterscheiden:
Skifahrer(1), Skifahrer(2), …
Habe schon die Klassen SkiFahrer, SkiPiste, SkiLift, WarteSchlange soweit fertig. Was ich nicht hinkriege ist die getMethode() von der Warteschlange. Ich habe mir überlegt eine Klasse SkiFahrerPaar anzulegen..
Hat jemand eine Idee wie ich die get() Methode richtig implementiere damit ich diese dann im Consumer ( SkiLift)einbauen kann?

public class SkiFahrer {
	
	static int id;
	
	public SkiFahrer(){
		
		id++; }}

public class SkiFahrerPaar {
	
	SkiFahrer a;
	SkiFahrer b;
		
	public SkiFahrerPaar(SkiFahrer a, SkiFahrer b){
		
		this.a = a; this.b = b; }}

import java.util.*;

public class WarteSchlange {
	
	public LinkedList <SkiFahrer> schlange;
	int anzahl;
	
	//Der Warteschlange wird ein SkiFahrer zugefügt
	synchronized public void put (SkiFahrer f) {
		
		while(true){
			
			schlange.add(f);
			anzahl++;
			System.out.println("Der Skifahrer Nr [ "+ anzahl +" ] kommt");
			
		/*	try{
				wait((long) (Math.random() * 300+1 ));	
			}
			catch (InterruptedException e) {
				  System.out.println("Ein Fehler" + e);	*/
		}
	}
	
	//Aus der Warteschlange werden die ersten beiden SkiFahrer entnommen
	synchronized public SkiFahrerPaar get() {
		
		while(schlange.size()<2){
			
			try { wait(); } catch(InterruptedException e) {}
		}
		
		SkiFahrer sf1 = schlange.get(0);
		SkiFahrer sf2 = schlange.get(1);
		schlange.removeFirst();
		schlange.removeFirst();
		
		notifyAll();
		return new SkiFahrerPaar(sf1,sf2);//,schlange.get(1)); 
	}
	
	public WarteSchlange(){
		
		schlange = new LinkedList<SkiFahrer>(); }}

public class SkiPiste extends Thread{
	
	WarteSchlange schlange;
	
	public void run(){
		

		while(true){
				
		    schlange.put(new SkiFahrer());
     		
			try{
				wait((long) (Math.random() * 300+1 ));	
			}
			catch (InterruptedException e) {
				  System.out.println("Ein Fehler" + e);		
		 }}}	
		

		public SkiPiste( WarteSchlange schlange){
			this.schlange=schlange;
		}}

public class Skilift extends Thread {
	
	WarteSchlange schlange;
	
	
	public void run(){
		
		while(true){
			
		//	if(schlange.)
			
			/*try{
				wait((long) (Math.random() * 300+1 ));	
			}
			catch (InterruptedException e) {
				  System.out.println("Ein Fehler" + e);
			}
			
			schlange.get();*/
		//	schlange.get().a.;

		}}
	
	
	public Skilift(WarteSchlange schlange){
		this.schlange = schlange;
	}}

 

[Joker]

1. anstatt "synchronized public" schreibt man "public synchronized"

2. Schau dir die Implementierungen der BlockingQueue an, macht das ganze viel einfacher. Anstatt deiner get-Methode kannst du dann die z.B. LinkedBlockingQueue#take Methode benutzen.

 

[Mirko_Gast]

Oh... Ups...Danke.
Laut Lehrer müssen wir die LinkedList benutzen :-(

 

[Mirko_Gast]

Habe mein Code ein Wenig verändert....

public class MonitorMitPuffer {

	public static void main(String[] args) {

		WarteSchlange schlange = new WarteSchlange();
		SkiPiste skipiste = new SkiPiste(schlange);
		Skilift skilift = new Skilift(schlange);

		skipiste.start();
		skilift.start();
	}
}

public class WarteSchlange {

	public LinkedList<SkiFahrer> schlange;

	int anzahl;

	// Der Warteschlange wird ein SkiFahrer zugefügt
	public synchronized void put(SkiFahrer f) {

		while (true) {

			schlange.add(f);
			anzahl++;
			System.out.println("Der Skifahrer Nr [ " + anzahl + " ] kommt");

			try {
				wait((long) (Math.random() * 300 + 1));
			} catch (InterruptedException e) {
				System.out.println("Ein Fehler" + e);
			}
		}
	}

	// Aus der Warteschlange werden die ersten beiden SkiFahrer entnommen
	public synchronized SkiFahrerPaar get() {

		while (schlange.size() < 2) {

			try {
				wait();
			} catch (InterruptedException e) {
			}
		}
		
		
		SkiFahrer sf1 = schlange.get(0);
		SkiFahrer sf2 = schlange.get(1);
		schlange.removeFirst();
		schlange.removeFirst();
		System.out.println("SkiFahrer wurde mitgenommen!");

		notify();
		return new SkiFahrerPaar(sf1, sf2);
	}

	public WarteSchlange() {

		schlange = new LinkedList<SkiFahrer>();
	}
}

public class Skilift extends Thread {

	WarteSchlange schlange;

	public void run() {

		try {
			sleep(350);
		} catch (InterruptedException e) {
			System.out.println("Ein Fehler" + e);
		}
		schlange.get();

	}

	public Skilift(WarteSchlange schlange) {
		this.schlange = schlange;
	}
}

public class SkiPiste extends Thread{
	
	WarteSchlange schlange;
	
	public void run(){
		

		while(true){
				
		    schlange.put(new SkiFahrer());
     		
			try{
				wait((long) (Math.random() * 300+1 ));	
			}
			catch (InterruptedException e) {
				  System.out.println("Ein Fehler" + e);		
		 }	
		}
	   }
		

		public SkiPiste( WarteSchlange schlange){
			this.schlange=schlange;
		}
	}

 

[Gast]

Oh..

 

[Frustrierter Infostudi]

öhm, das Programm funktioniert doch aber nocht nicht, oder ? ^^

ich habe dieselbe Aufgabe gestellt bekommen, habe allerdings auch probleme 8(

 

[Gast]

soweit ich das beurteilen kann, läuft das Programm nur für das erste "SkiFahrerPaar", danach greift das Teilstück
public synchronized SkiFahrerPaar get() nicht mehr, warum ist mir aber im Moment auch schleierhaft.

 

[Joker]

hier mal eine Lösung basierend auf LinkedBlockingQueue (die basiert auf einer LinkedList, vielleicht reicht das ja aus ):

import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;


public class Skilift {
    private static final int MAX_DRIVER = 20;
    private static final int MAX_DRIVER_ON_TRACK = 20;

    private BlockingQueue<Skifahrer> fahrerWaitingQueue;
    private BlockingQueue<Skifahrer> fahrerOnTrack;
    private BuegelTask buegel;
    private SkipistenTask piste;
    
    public Skilift() {
        fahrerWaitingQueue = new LinkedBlockingQueue<Skifahrer>(MAX_DRIVER);
        fahrerOnTrack = new LinkedBlockingQueue<Skifahrer>(MAX_DRIVER_ON_TRACK);
       
        createSkiDriver();  
       
        buegel = new BuegelTask(this);
        piste = new SkipistenTask(this);
       
        buegel.start();
        piste.start();
    }
    
    public void createSkiDriver() {       
        Skifahrer f;
        for(int i = 0; i< MAX_DRIVER;i++) {
            f = new Skifahrer(i+"");           
            fahrerWaitingQueue.add(f);
        }
    }
    
    public void transportPeople() {
        try {           
            Skifahrer f1 = fahrerWaitingQueue.take();                      
            Skifahrer f2 = fahrerWaitingQueue.take();
            System.out.println("Transportiere " + f1.getName()+ " und "+f2.getName());
                     
            fahrerOnTrack.offer(f1);           
            fahrerOnTrack.offer(f2);    
           
        } catch (InterruptedException ie) {
            ie.printStackTrace();
        }
    }
       
    public void putDriverInWaitingQueue() {
        try {
            Skifahrer f1 = fahrerOnTrack.take();
            System.out.println("Fahrer " + f1.getName() + " stellt sich in die Warteschlange!");
            fahrerWaitingQueue.offer(f1);
        } catch (InterruptedException ie) {
            ie.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        new Skilift();
    }
}

class SkipistenTask extends Thread {

    private Skilift lift;
    private Random random;
    public SkipistenTask(Skilift lift) {
        this.lift = lift;
        random = new Random();
    }

    @Override
    public void run() {
        while (true) {
            try {
                sleep(random.nextInt(400));
                System.out.println("Fahrer im Ziel!");
                lift.putDriverInWaitingQueue();     
              
            } catch (InterruptedException ie) {
                ie.printStackTrace();
            }
        }
    }
}

class BuegelTask extends Thread {

    private static final int BUEGEL_INTERVALL = 200;
    private Skilift lift;

    public BuegelTask(Skilift lift) {
        this.lift = lift;
    }

    @Override
    public void run() {
        while (true) {
            try {
                sleep(BUEGEL_INTERVALL);
                System.out.println("Buegel kommt!");
                lift.transportPeople();
             
            } catch (InterruptedException ie) {
                ie.printStackTrace();
            }
        }
    }
}

class Skifahrer {
    private String name;
    public Skifahrer(String name) {
        this.name=name;
    }
    
    public synchronized String getName() {
        return name;
    }
     
}

Das Deutsch/Englisch Mischmasch sollte man aber noch beseitigen, hab die Klassen und Variablennamen soweit es geht aus eurer Teillösung kopiert und in ein altes Beispiel von mir eingefügt