In den letzten Tagen habe ich an der Implementierung von Prioritätswarteschlangen gearbeitet, da die Thread-Sicherheit berücksichtigt werden muss. PriorityQueue ist nicht anwendbar. Eine sehr einfache Implementierungsmethode besteht darin, diejenigen mit höherer Priorität in eine Warteschlange einzufügen und diejenigen mit niedrigerer Priorität in eine andere Warteschlange. Beim Abrufen der Nummern holen Sie zuerst die Nummern aus der Warteschlange mit höherer Priorität. Der Nachteil dabei ist, dass es umso mehr Warteschlangen gibt, je mehr Prioritätsstufen es gibt.
Da es Thread-sicher sein muss, verwendet die Warteschlange ConcurrentLinkedQueue, das Thread-sicher ist, und in der API-Dokumentation heißt es, dass ConcurrentLinkedQueue einen effektiven „wartefreien“ Algorithmus verwendet, sodass der Durchsatz sehr gut ist!
Der einfache Code lautet wie folgt:
Pakettest;
import java.util.concurrent.ConcurrentLinkedQueue;
öffentliche Klasse PriorityQueueTest {
public static void main(String[] args) {
ConcurrentLinkedQueue <String> highPriority = new ConcurrentLinkedQueue <String>(); //Hohe Priorität
ConcurrentLinkedQueue <String> lowPriority = new ConcurrentLinkedQueue <String>(); //Niedrige Priorität
highPriority.add( "aaa" );
highPriority.add( "bbb" );
highPriority.add( "111" );
lowPriority.add( "ccc" );
lowPriority.add( "ddd" );
lowPriority.add( "222" );
int i = 0 ,j = 0 , k= 0 ;
while(true){
while(true){
if (!highPriority.isEmpty()){
System.out.print(highPriority.remove());
i++;
k++;
System.out.println( ", i = " +i+ ", k=" +k);
brechen ;
}
if (!lowPriority.isEmpty()){
System.out.print(lowPriority.remove());
j++;
k++;
System.out.println( ", j = " +j+ ", k=" +k);
brechen ;
}
brechen ;
}
versuchen {
Thread.sleep(100);
} Catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
Eine andere Möglichkeit besteht darin, eine sehr leistungsstarke Prioritätswarteschlange zu implementieren, indem Sie PriorityQueue erben, die Comparable-Schnittstelle implementieren und dann die CompareTo-Methode selbst neu schreiben. Der Nachteil besteht jedoch darin, dass sie nicht threadsicher ist!
Der Code lautet wie folgt:
Pakettest;
import java.util.PriorityQueue;
Die öffentliche Klasse PriorityTest erweitert PriorityQueue<PriorityTest.Test>{
statische Klasse Test implementiert Comparable<Test>{
String-Paket;
int Stolz;
public Test(String packet, int Pride) {
this .packet = packet;
this .priotity = priotity;
}
public int CompareTo(Test arg) {
if (priotity < arg.priotity)
Rückgabe 1;
sonst wenn (priotity > arg.priotity)
Rückkehr - 1 ;
anders
0 zurückgeben;
}
öffentlicher String toString(){
Rücksendepaket;
}
}
public void add(String str, int priorität){
super .add( new Test(str,priority));
}
public static void main(String args[]){
PriorityTest pTest = new PriorityTest();
pTest.add( "aaa" , 3 ); //Höchste Priorität
pTest.add( "bbb" , 2 );
pTest.add( "ccc" , 1 );
while (!pTest.isEmpty()){
System.out.println(pTest.remove());
}
}