Eingeführt:
Vor einiger Zeit ging ich zur Bank, um das Geschäft zu bewältigen, und es waren so viele Leute in der Schlange. Es dauerte weniger als 5 Minuten, um das Geschäft alleine zu bewältigen, aber ich wartete zwei Stunden (ich glaube, viele Menschen haben diese Situation begegnet). Ich war sprachlos in Bezug auf dieses Servicestufe, aber das Problem tritt wieder auf. Die Bank sollte mehrere Fenster öffnen, um die gesamte Servicequalität und die Nutzungsressourcenquote zu gewährleisten? Als nächstes werden wir dieses Problem durch die Warteentheorie simulieren.
Einführung in die Warteschlangentheorie
Die Warteschlangentheorie ist eine mathematische Theorie und Methode, die das Phänomen der zufälligen Sammlung und Verteilung von Systemen und das Arbeitsingenieurwesen zufälliger Systeme untersucht. Es ist auch als Theorie von zufälligen Service -Systemen bekannt und ist ein Zweig der Operationsforschung. Vereinfachen wir die folgende Warteschlangentheorie und sehen Sie sich zuerst die folgende Abbildung an:
Auf der linken Seite des Bildes arrangieren wir mehrere blaue Servicesschmelzes, mit roten Kunden, die möglicherweise rechts vorbeikommen, und einen gelben Wartebereich in der Mitte. Wenn ein Servicesschalter im Leerlauf ist, können Kunden direkt Dienstleistungen erhalten, da sie sonst im gelben Bereich warten müssen. Die Reihenfolge des Kundendienstes übernimmt das Prinzip des ersten und aktuellen Dienstes. Wenn wir nun die Wahrscheinlichkeitsverteilung der Kunden kennen, wie können wir dann mehrere Serviceschalter links arrangieren, um ein besseres Servicestufe zu erreichen und die Nutzungsrate des Service Desk zu gewährleisten? Als nächstes werden wir ein Modell erstellen, um dieses Problem zu simulieren.
Die Warteschlangentheorie wird Schritt für Schritt implementiert
1) Für die Warteschlangentheorie müssen wir zunächst die Kundenattribute ermitteln, wissen, wann der Kunde eintrifft, die erforderliche Servicezeit usw. Wir erstellen zuerst eine Kundenklasse, in der wir die maximale und minimale Zeit für den Kundendienst angeben. Um zu vereinfachen, denken wir hier direkt, dass die Servicezeit völlig zufällig ist:
Public Class CustomerBean {// Mindestdienstzeit private statische int minservetime = 3 * 1000; // Maximale Servicezeit private statische int maxservetime = 15 * 1000; // Kunde erreicht Zeit private lange Ankunft; // Kundenbedürfnisse Servicezeit Private int Servetime; public CustomerBean () {// Ankunftszeit an Arrivaltime = System.currentTimemillis (); // zufällige Set -Kundendienstzeitszeit servetime = (int) (math.random () * (maxservetime - minservetime) + minservetime); }} 2) Wir definieren den Kunden oben und müssen dann eine Warteschlange definieren. Schauen wir uns zunächst die Attribute der Warteschlange an. Hier definieren wir ein Array, um die Kunden in der Warteschlange zu retten, die minimalen und maximalen Zeitintervalle für den nächsten Kunden und die Wahrscheinlichkeit, dass der Kunde kommt (hier kurz zu erklären, wenn die Intervallzeit des nächsten Kunden 3 ist, ist es 3, aber es wird durch die Wahrscheinlichkeit berechnet, dass der Kunde die Kunde nicht so gut wie möglich ist.
Public Class Customerquene {// Warten auf die Kundenwarteschlange private LinkedList <CusticesBean> customer = new LinkedList <CusticesBean> (); // die kürzeste Zeit für den nächsten Kunden, der privat in mintime = 0 kommt; // die maximale Zeit für den nächsten Kunden, privat int maximal = 1 * 1000; // Die Wahrscheinlichkeit, dass die kommenden Kunden privater Doppelrate = 0,9; // Identifizieren Sie, ob der Kunden private boolesche Flagge = true; // die maximale Anzahl von Personen, die sich privat int maxwaitnum = 0 anstellen; } 3) Wenn Kunden und Warteschlangen vorhanden sind, richten wir einen Thread ein, um Kunden zu generieren, um kontinuierlich Kunden zu generieren. Hier sind die oben erwähnten Zeit- und Wahrscheinlichkeitsverteilungen.
/ ***@Beschreibung: Kundenthread erstellen*@Version: 1.1.0*/ Private Class CustomerThread erweitert Thread {private CustomerThread (String -Name) {super (name); } @Override public void run () {while (flag) {// Fügen Sie am Ende des Teams einen neuen Kunden hinzu, wenn (math.random () <rate) {customer.addlast (new CustomerBean ()); if (maxwaitnum <customer.size ()) {maxwaitnum = customer.size (); }} int sleepTime = (int) (math.random () * (maxtime - mintime) + mintime); probieren Sie {TimeUnit.Milliseconds.sleep (Schlafzeit); } catch (Ausnahme e) {e.printstacktrace (); }}}}} 4) Wenn Kunden in der Warteschlange stehen, um den kostenlosen Servicesschalter zu verkürzen, müssen Sie den Kunden in den Leiter des Teams bringen, um den Service zu erhalten.
public synchronisierte customerBean getCustomerbean () {if (Kunden == NULL || customer.size () <1) {return null; } return customer.removefirst (); } 5) Kundenbezogene Attribute und Methoden sind alle bereit. Setzen wir die Attribute für Service Desk zu tun. Hier setzen wir den Service Desk direkt auf einen Thread, um einige Serviceindikatoren zu definieren, wie z.
Public Class ServantThread erweitert Thread {// Anzahl der Servicekunden privat static int Customernum = 0; // Wartezeit in der Wartezeit private statische int sumwaittime = 0; // Total Service Time Private statische Int Sumservetime = 0; // Maximale Wartezeit private statische int maxwaittime = 0; private boolesche Flagge = Falsch; privater Zeichenfolge Name; } 6) Die Hauptaufgabe des Service Desk besteht darin, Kunden zu bedienen. Hier schreiben wir Vorgänge, die sich darauf beziehen, Kunden in die Run -Methode des Threads zu bedienen.
public void run () {flag = true; while (flag) {CustomerBean Customer = CustomerQuene.getCustomerquene (). GetCustomerbean (); // Wenn der Kunden -Thread geschlossen wurde und es keine Kunden in der Warteschlange gibt, schließt und veröffentlicht der Service Desk Thread, wenn (Customer == null) {if (! Customerquene.getCustomerquene (). Isflag ()) {flag = false; drucken(); } weitermachen; } long Now = System.currentTimemillis (); int waittime = (int) (jetzt - customer.getarrivetime ()); // Speichern Sie die maximale Wartezeit, wenn (WaitTime> maxwaittime) {maxwaittime = waittime; } // Die Schlafzeit ist die Servicezeit des Kunden, die den Servicezeitraum in diesem Zeitraum für Kunden darstellt. Versuche {TimeUnit.Milliseconds.sleep (Customer.getServetime ()); } catch (Ausnahme e) {e.printstacktrace (); } System.err.println (Name + "Zeit, um Kunden zu bedienen:" + customer.getServeServeTime () + "MS/T -Kunde Warten:" + WaitTime + "MS"); Customernum ++; Sumwaittime += WaitTime; sumservetime += customer.getServeTime (); }} 7) Schließlich schreiben wir ein Testmodell, um die Serviceebene zu überprüfen
/ ** *@Beschreibung: */ package com.lulei.opsearch.quene; Import Java.util.Concurrent.TimeUnit; public class test {public static void main (String [] args) {// Öffnen Sie das Türsystem.out.println ("Öffnen Sie die Tür und nehmen Sie die Kunden ab!"); boolesche Flagge = wahr; CustomerQuene.getCustomerquene (); lang a = system.currentTimemillis (); int Servicenum = 10; für (int i = 0; i <servicenum; i ++) {Servantthread Thread = New ServantThread ("Service Desk"+i); Thread.Start (); } while (flag) {lang b = system.currentTimemillis (); if (b - a> 1 * 60 * 1000 && flag) {// schließen flag = false; CustomerQuene.getCustomerquene (). Close (); System.out.println ("Schließen Sie die Tür und holen Sie keine Kunden ab!"); } System.out.println ("Systemlaufzeit:" + (b -a) + "ms"); System.out.println ("System Leerlaufzeit:" + ((b -a) * Servantnum - Servantthread.getSumServeTime ())); DientThread.print (); Versuchen Sie {TimeUnit.Seconds.sleep (2); } catch (Ausnahme e) {e.printstacktrace (); }}}} Auslaufergebnisse
1) Betriebsstart
2) Der Kunde generiert Thread Schließen
3) endgültige Serviceebene
Durch die Änderung der Anzahl der Servicesschmelzungen können Sie bewerten, wie viele Servicesschmelzungen in der aktuellen Kundensituation eingerichtet werden sollen.
Vollständiger Code
1) Kundenkategorie
/ ** *@Beschreibung: */ package com.lulei.opsearch.quene; Public Class CustomerBean {// Mindestdienstzeit private statische int minservetime = 3 * 1000; // Maximale Servicezeit private statische int maxservetime = 15 * 1000; // Kunde erreicht Zeit private lange Ankunft; // Kundenbedürfnisse Servicezeit Private int Servetime; public CustomerBean () {// Ankunftszeit an arrivetime = system.currentTimemillis (); // zufällig Kundendienstzeit servetime = (int) (math.random () * (maxservetime - minservetime) + minservetime); } public static int getMinServeTime () {return minservetime; } public static void setMinServeTime (int minservetime) {customerBean.minservetime = minServetime; } public static int getmaxServeTime () {return maxservetime; } public static void setMaxServeTime (int maxservetime) {customerBean.maxServeTime = maxservetime; } public long getarrivetime () {return arrivetime; } public void setarrivetime (lange Ankunft) {this.arrivetime = arrivetime; } public int getServeTime () {return servetime; } public void setServeTime (int servetime) {this.servetime = servetime; }}2) Kundenwarteschlange
/ ** *@Beschreibung: */ package com.lulei.opsearch.quene; import Java.util.linkedList; Import Java.util.Concurrent.TimeUnit; Public Class Customerquene {// Warten auf die Kundenwarteschlange private LinkedList <CusticesBean> customer = new LinkedList <CusticesBean> (); // die kürzeste Zeit für den nächsten Kunden, der privat in mintime = 0 wird; // die maximale Zeit für den nächsten Kunden, privat int maximal = 1 * 1000; // die Wahrscheinlichkeit, dass der private Doppelrate von Kunden = 0,9; // Identifizieren Sie, ob Kunden weiterhin eine private boolesche Flagge = True generieren; // Maximale Anzahl der Personen in der Lage, private int maxwaitnum = 0 in der Lage zu sein; public int getmaxwaitnum () {return maxwaitnum; } public boolean isflag () {return flag; } / ** * @Return * @Author: lulei * @Description: Bringen Sie den Kunden in die Warteschlange * / public synchronisierte CustomerBean getCustomerbean () {if (customer == null || customer.size () <1) {return null; } return customer.removefirst (); } public void close () {if (flag) {flag = false; }} / ** * @return * @Author: lulei * @Description: Holen Sie sich die Anzahl der wartenden Kunden * / public int getwaitcustomernum () {return customer.size (); } / ***@Beschreibung: Customer -Thread generieren*@Version: 1.1.0* / private Class CustomerThread erweitert Thread {private CustomerThread (String -Name) {Super (Name); } @Override public void run () {while (flag) {// Fügen Sie am Ende des Teams einen neuen Kunden hinzu, wenn (math.random () <rate) {customer.addlast (new CustomerBean ()); if (maxwaitnum <customer.size ()) {maxwaitnum = customer.size (); }} int sleepTime = (int) (math.random () * (maxtime - mintime) + mintime); probieren Sie {TimeUnit.Milliseconds.sleep (Schlafzeit); } catch (Ausnahme e) {e.printstacktrace (); }}}}} // Singleton -Modus Starten Sie private statische Klasse customerquedao {private statische Customerquene CustomerQuene = new CustomerQuene (); } private customerQuene () {CustomerThread CustomerThread = New CustomerThread ("Customer Generation Thread"); CustomerThread.Start (); } public static customerquene getCustomerquene () {return CustomerQuedao.Customerquene; } // Singleton -Modus end public int getMintime () {return Mintime; } public void setMintime (int mintime) {this.mintime = mintime; } public int getMaxTime () {return maxime; } public void setmaxTime (int maxime) {this.maxTime = maxime; } public double getRate () {Return Rate; } public void setRate (doppelte Rate) {this.rate = rate; }} 3) Service Desk Thread
/ ** *@Beschreibung: */ package com.lulei.opsearch.quene; Import Java.util.Concurrent.TimeUnit; import com.lulei.util.parseutil; Public Class ServantThread erweitert Thread {// Anzahl der Servicekunden privat static int Customernum = 0; // Wartezeit in der Wartezeit private statische int sumwaittime = 0; // Total Service Time Private statische Int Sumservetime = 0; // Maximale Wartezeit private statische int maxwaittime = 0; private boolesche Flagge = Falsch; privater Zeichenfolge Name; public servantThread (String name) {Super (Name); this.name = name; } public static int getmaxWaittime () {return maxwaittime; } public static int getUMServeTime () {return sumservetime; } @Override public void run () {flag = true; while (flag) {CustomerBean Customer = CustomerQuene.getCustomerquene (). GetCustomerbean (); // Wenn der Kunden -Thread geschlossen wurde und es keine Kunden in der Warteschlange gibt, schließt und veröffentlicht der Service Desk Thread, wenn (Customer == null) {if (! Customerquene.getCustomerquene (). Isflag ()) {flag = false; drucken(); } weitermachen; } long Now = System.currentTimemillis (); int waittime = (int) (jetzt - customer.getarrivetime ()); // Speichern Sie die maximale Wartezeit, wenn (WaitTime> maxwaittime) {maxwaittime = waittime; } // Schlafzeit ist die Servicezeit des Kunden, die den Versuch des Kunden darstellt. } catch (Ausnahme e) {e.printstacktrace (); } System.err.println (Name + "Zeit, um Kunden zu bedienen:" + customer.getServetime () + "MS/T -Kunde Warten:" + WaitTime + "MS"); Customernum ++; Sumwaittime += WaitTime; sumservetime += customer.getServeTime (); }} public static void print () {if (benutzerdefiniert> 0) { System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // Die durchschnittliche Wartezeit des Kunden ausgeben und zwei Dezimalplätze beibehalten. Customernum), 2) + "MS"); 4) Testen Sie das Modell
/ ** *@Beschreibung: */ package com.lulei.opsearch.quene; Import Java.util.Concurrent.TimeUnit; public class test {public static void main (String [] args) {// Öffnen Sie das Türsystem.out.println ("Öffnen Sie die Tür und nehmen Sie die Kunden ab!"); boolesche Flagge = wahr; CustomerQuene.getCustomerquene (); lang a = system.currentTimemillis (); int Servicenum = 10; für (int i = 0; i <servicenum; i ++) {Servantthread Thread = New ServantThread ("Service Desk"+i); Thread.Start (); } while (flag) {lang b = system.currentTimemillis (); if (b - a> 1 * 60 * 1000 && flag) {// schließen flag = false; CustomerQuene.getCustomerquene (). Close (); System.out.println ("Schließen Sie die Tür und holen Sie keine Kunden ab!"); } System.out.println ("Systemlaufzeit:" + (b -a) + "ms"); System.out.println ("System Leerlaufzeit:" + ((b -a) * Servantnum - Servantthread.getSumServeTime ())); DientThread.print (); Versuchen Sie {TimeUnit.Seconds.sleep (2); } catch (Ausnahme e) {e.printstacktrace (); }}}}Das obige ist eine detaillierte Einführung in die Prinzipien der Java -Implementierung der Warteschlangentheorie. Ich hoffe, es wird für das Lernen aller hilfreich sein.