Universität Paderborn - Home Universität Paderborn
Die Universität der Informationsgesellschaft

Grundlagen der Programmierung 2 SS 2005 - Datei Restaurant.java

import java.util.Random;

public class Restaurant
{  // Die Klasse Restaurant wird als Monitor realisiert.

   public Restaurant(int anzTische, int minTisch, int maxTisch)
   {  // Restaurant mit anzTische Tischen erzeugen, Größe für jeden
      // Tisch zufällig zwischen minTisch und maxTisch wählen
      rand = new Random();
      tische = new Tisch[anzTische];
      for (int i = 0; i < tische.length; i++)
      {  int stühle = zufall(minTisch, maxTisch);
         tische[i] = new Tisch(stühle);
         if (stühle > größterTisch)
            größterTisch = stühle;
      }
   }

   synchronized public Tisch platzieren (int anz) 
   {  int n = tische.length;
      System.out.println("Es wird ein Tisch mit " + 
			  anz + " Plätzen benötigt");
      while (!tischSuche(anz)) 
      {  try { wait(); } 
	     catch (InterruptedException e) {}
      }
      gefundenerTisch.hinsetzen(anz);
      return gefundenerTisch;
   }

   synchronized public void verlassen (Tisch tisch, int anz) 
   {  tisch.aufstehen(anz);
      notifyAll();
   }

   private boolean tischSuche(int anz) 
   {  int n = tische.length;
      gefundenerTisch = null;
      for (int i = 0; i < tische.length; i++) 
      {  // suche nach einem passenden, leeren Tisch
         if (tische[i].istLeer() &&
             tische[i].anzahlStühle() == anz) 
         {  System.out.println("Leerer Tisch mit " + 
                               anz + " Plätzen gefunden");
            gefundenerTisch = tische[i];
            return true;
         }
      }
      for (int i = 0; i < tische.length; i++) 
      {  // suche nach einem zu großen, leeren Tisch
         if (tische[i].istLeer() &&
             tische[i].nochPlatz(anz)) 
         {  System.out.println("Größerer Tisch mit " + 
                               anz + " Plätzen gefunden");
            gefundenerTisch = tische[i];
            return true;
         }
      }
      for (int i = 0; i < tische.length; i++) 
      {  // suche nach einem Tisch mit ausreichend Platz
         if (tische[i].nochPlatz(anz)) 
         {  System.out.println("Tisch mit ausreichend Platz (" + 
                               anz + ") gefunden");
            gefundenerTisch = tische[i];
            return true;
         }
      }
      return false;
   }

   void simuliere (int anzGruppen, int minZeit, int maxZeit, int maxPause)
   {  // Besuch von anzGruppen Besuchergruppen im Restaurant simulieren
      // jede Gruppe benötigt zwischen minZeit und maxZeit Zeit zum Essen
      // spätestens alle maxPause Zeiteinheiten kommt eine neue Gruppe
      // keine Gruppe ist größer als der größte Tisch im Restaurant
      for (int i = 1; i <= anzGruppen; i++)
      {
         BesucherGruppe g =
            new BesucherGruppe(this, zufall(1, größterTisch),
                                     zufall(minZeit, maxZeit));
         g.start();
         try { Thread.sleep(zufall(1, maxPause)); }
	     catch (InterruptedException e) {};
      }
   }

   private int zufall(int min, int max)
   {
      // erzeuge Zufallszahl zwischen min und max (jeweils einschließlich)
      return rand.nextInt(max - min + 1) + min;
   }

   private Tisch gefundenerTisch; // hier wird Gruppe platziert
   private Tisch[] tische;        // uns interessieren nur die Tische
   private int größterTisch = 0;  // max. mögliche Gruppengröße
   private Random rand;           // zur Erzeugung von Zufallszahlen

   public static void main (String[] args)
   {  // Hauptprogramm zum Testen:
      // simuliert ein Restaurant mit 6 Tischen für 2 bis 10 Personen
      // Simulation umfasst Besuch von 40 Gruppen im Restaurant
      Restaurant r = new Restaurant(6, 2, 10);
      r.simuliere(40,1000,20000,2000);
   }
}

Generiert mit Camelot | Probleme mit Camelot? | Geändert am: 03.06.2005