Implémentation de la file d'attente prioritaire en Java

Ces derniers jours, j'ai travaillé sur l'implémentation de files d'attente prioritaires. Parce que la sécurité des threads doit être prise en compte, PriorityQueue n'est pas applicable. Une méthode de mise en œuvre très simple consiste à insérer ceux avec une priorité plus élevée dans une file d'attente et ceux avec une priorité inférieure dans une autre file d'attente. Lors de la récupération des numéros, récupérez d'abord les numéros de la file d'attente avec une priorité plus élevée. L’inconvénient est que plus il y a de niveaux de priorité, plus il y a de files d’attente.
Parce qu'elle doit être thread-safe, la file d'attente utilise ConcurrentLinkedQueue, qui est thread-safe, et la documentation de l'API indique que ConcurrentLinkedQueue utilise un algorithme efficace « sans attente », donc son débit est très bon !
Le code simple est le suivant :
test de paquet ;

importer java.util.concurrent.ConcurrentLinkedQueue ;

classe publique PriorityQueueTest {

public static void main (String[] arguments) {
ConcurrentLinkedQueue <String> highPriority = new ConcurrentLinkedQueue <String>( //Haute priorité);
ConcurrentLinkedQueue <String> lowPriority = new ConcurrentLinkedQueue <String>( //Faible priorité);

highPriority.add( "aaa" );
highPriority.add( "bbb" );
highPriority.add( "111" );

lowPriority.add( "ccc" );
lowPriority.add( "ddd" );
lowPriority.add( "222" );

int je = 0 ,j = 0 , k= 0 ;
tandis que(vrai){
tandis que(vrai){
si (!highPriority.isEmpty()){
System.out.print(highPriority.remove());
je++;
k++;
System.out.println( ", i = " +i+ ", k=" +k);
casser ;
}
si (!lowPriority.isEmpty()){
System.out.print(lowPriority.remove());
j++;
k++;
System.out.println( ", j = " +j+ ", k=" +k);
casser ;
}
casser ;
}
essayer {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

Une autre façon consiste à implémenter une file d'attente prioritaire très puissante en héritant de PriorityQueue et en implémentant l'interface Comparable, puis en réécrivant vous-même la méthode compareTo. Cependant, l'inconvénient est qu'elle n'est pas thread-safe !
Le code est le suivant :
test de paquet ;

importer java.util.PriorityQueue ;

la classe publique PriorityTest étend PriorityQueue<PriorityTest.Test>{
classe statique Test implémente Comparable<Test>{
Paquet de chaînes ;
int fierté;

Test public (paquet de chaînes, fierté int) {
ce .packet = paquet ;
ceci .priotity = priorité ;
}

public int compareTo (Argument de test) {
if (priorité < arg.priotity)
renvoyer 1 ;
sinon si (priotité > arg.priotity)
retourner - 1 ;
autre
renvoie 0 ;
}

chaîne publique toString(){
paquet de retour ;
}
}

public void add(String str, int priorité){
super .add( new Test(str,priority));
}

public static void main(String args[]){
PriorityTest pTest = new PriorityTest();
pTest.add( "aaa" , 3 ); //Priorité la plus élevée
pTest.add( "bbb" , 2 );
pTest.add( "ccc" , 1 );

tandis que (!pTest.isEmpty()){
System.out.println(pTest.remove());
}
}