En los últimos días, he estado trabajando en la implementación de colas prioritarias. Debido a que se debe tener en cuenta la seguridad de los subprocesos, PriorityQueue no es aplicable. Un método de implementación muy simple es insertar los que tienen mayor prioridad en una cola y los que tienen menor prioridad en otra cola. Al recuperar los números, primero obtenga los números de la cola con mayor prioridad. La desventaja de esto es que cuantos más niveles de prioridad haya, más colas habrá.
Debido a que debe ser seguro para subprocesos, la cola usa ConcurrentLinkedQueue, que es seguro para subprocesos, y la documentación de la API dice que ConcurrentLinkedQueue usa un algoritmo efectivo "sin espera", por lo que su rendimiento es muy bueno.
El código simple es el siguiente:
prueba de paquete;
importar java.util.concurrent.ConcurrentLinkedQueue;
clase pública PriorityQueueTest {
público estático vacío principal (String [] argumentos) {
ConcurrentLinkedQueue <String> highPriority = new ConcurrentLinkedQueue <String>() //Alta prioridad
ConcurrentLinkedQueue <String> lowPriority = new ConcurrentLinkedQueue <String>() //Baja prioridad
altaPrioridad.add( "aaa" );
altaPrioridad.add( "bbb" );
altaPrioridad.add( "111" );
prioridadbaja.add( "ccc" );
prioridadbaja.add( "ddd" );
prioridadbaja.add( "222" );
int yo = 0 ,j = 0 , k= 0 ;
mientras (verdadero) {
mientras (verdadero) {
si (!highPriority.isEmpty()){
System.out.print(highPriority.remove());
yo ++;
k++;
System.out.println( ", i = " +i+ ", k=" +k);
romper ;
}
si (!lowPriority.isEmpty()){
System.out.print(lowPriority.remove());
j++;
k++;
System.out.println( ", j = " +j+ ", k=" +k);
romper ;
}
romper ;
}
intentar {
Hilo.dormir(100);
} captura (Excepción interrumpida e) {
e.printStackTrace();
}
}
}
}
Otra forma es implementar una cola de prioridad muy poderosa heredando PriorityQueue e implementando la interfaz Comparable, y luego reescribiendo el método compareTo usted mismo. Sin embargo, la desventaja es que no es seguro para subprocesos.
El código es el siguiente:
prueba de paquete;
importar java.util.PriorityQueue;
la clase pública PriorityTest extiende PriorityQueue<PriorityTest.Test>{
clase estática Prueba implementa Comparable<Prueba>{
Paquete de cuerdas;
orgullo internacional;
Prueba pública (paquete de cadenas, int orgullo) {
este .paquete = paquete;
esta .prioridad = prioridad;
}
público int comparar con (argumento de prueba) {
if (prioridad <arg.prioridad)
devolver 1;
de lo contrario si (prioridad > arg.priotidad)
retorno - 1 ;
demás
devolver 0;
}
cadena pública toString(){
paquete de devolución;
}
}
agregar vacío público (cadena cadena, prioridad int) {
super .add(nueva Prueba(cadena,prioridad));
}
principal vacío estático público (String args []) {
Prueba de Prioridad pTest = nueva Prueba de Prioridad();
pTest.add( "aaa", 3 ); //Prioridad más alta
pTest.add( "bbb", 2 );
pTest.add( "ccc", 1 );
mientras (!pTest.isEmpty()){
System.out.println(pTest.remove());
}
}