Implementação de fila de prioridade em java

Nos últimos dias, tenho trabalhado na implementação de filas prioritárias. Como a segurança do thread deve ser levada em consideração, PriorityQueue não é aplicável. Um método de implementação muito simples é inserir aqueles com maior prioridade em uma fila e aqueles com menor prioridade em outra fila. Ao buscar os números, primeiro busque os números da fila com maior prioridade. A desvantagem disso é que quanto mais níveis de prioridade houver, mais filas haverá.
Como precisa ser thread-safe, a fila usa ConcurrentLinkedQueue, que é thread-safe, e a documentação da API diz que ConcurrentLinkedQueue usa um algoritmo eficaz "sem espera", portanto, seu rendimento é muito bom!
O código simples é o seguinte:
teste de pacote;

importar java.util.concurrent.ConcurrentLinkedQueue;

classe pública PriorityQueueTest {

public static void main(String[] args) {
ConcurrentLinkedQueue <String> highPriority = new ConcurrentLinkedQueue <String>();
ConcurrentLinkedQueue <String> lowPriority = new ConcurrentLinkedQueue <String>();

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

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

int eu = 0 ,j = 0 , k= 0 ;
enquanto(verdadeiro){
enquanto(verdadeiro){
if (!highPriority.isEmpty()){
System.out.print(highPriority.remove());
eu++;
k++;
System.out.println( ", i = " +i+ ", k=" +k);
quebrar ;
}
if (!lowPriority.isEmpty()){
System.out.print(lowPriority.remove());
j++;
k++;
System.out.println( ", j = " +j+ ", k=" +k);
quebrar ;
}
quebrar ;
}
tentar {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

Outra maneira é implementar uma fila de prioridade muito poderosa herdando PriorityQueue e implementando a interface Comparable e, em seguida, reescrevendo você mesmo o método compareTo. No entanto, a desvantagem é que ele não é seguro para threads!
O código é o seguinte:
teste de pacote;

importar java.util.PriorityQueue;

classe pública PriorityTest estende PriorityQueue<PriorityTest.Test>{
classe estática Teste implementa Comparable<Test>{
Pacote de strings;
orgulho interno;

public Test(String pacote, int orgulho) {
este .packet = pacote;
este .priotity = priotity;
}

public int compareTo(Teste arg) {
if (priotidade <arg.priotidade)
retornar 1;
senão if (priotidade > arg.priotidade)
retorno - 1 ;
outro
retornar 0;
}

String pública paraString(){
pacote de retorno;
}
}

public void add(String str, int prioridade){
super .add(novo Teste(str,prioridade));
}

public static void main(String args[]){
TestePrioridade pTest = new TestePrioridade();
pTest.add( "aaa", 3); //Prioridade mais alta
pTest.add("bbb", 2);
pTest.add("ccc", 1);

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