Dalam beberapa hari terakhir, saya sedang mengerjakan penerapan antrian prioritas. Karena keamanan thread harus dipertimbangkan, PriorityQueue tidak berlaku. Metode implementasi yang sangat sederhana adalah dengan memasukkan nomor dengan prioritas lebih tinggi ke dalam satu antrian, dan nomor dengan prioritas lebih rendah ke antrian lain. Saat mengambil nomor, pertama-tama ambil nomor dari antrian dengan prioritas lebih tinggi. Kerugiannya adalah semakin banyak tingkat prioritas, semakin banyak pula antriannya.
Karena harus thread-safe, antrian menggunakan ConcurrentLinkedQueue, yang merupakan thread-safe, dan dokumentasi API mengatakan bahwa ConcurrentLinkedQueue menggunakan algoritme "bebas tunggu" yang efektif, sehingga throughputnya sangat bagus!
Kode sederhananya adalah sebagai berikut:
tes paket;
impor java.util.concurrent.ConcurrentLinkedQueue;
Tes Antrean Prioritas kelas publik {
public static void main(String[] args) {
ConcurrentLinkedQueue <String> highPriority = new ConcurrentLinkedQueue <String>(); //Prioritas tinggi
ConcurrentLinkedQueue <String> lowPriority = new ConcurrentLinkedQueue <String>(); //Prioritas rendah
prioritas tinggi.tambahkan( "aaa" );
prioritas tinggi.tambahkan( "bbb" );
prioritas tinggi.tambahkan( "111" );
prioritas rendah.tambahkan( "ccc" );
prioritas rendah.tambahkan( "ddd" );
prioritas rendah.tambahkan( "222" );
ke dalam saya = 0 ,j = 0 , k= 0 ;
sementara(benar){
sementara(benar){
if (!Prioritas Tinggi.isEmpty()){
System.out.print(highPriority.remove());
saya++;
k++;
Sistem.keluar.println( ", i = " +i+ ", k=" +k);
merusak ;
}
if (!lowPriority.isEmpty()){
Sistem.keluar.cetak(prioritas rendah.hapus());
j++;
k++;
Sistem.keluar.println( ", j = " +j+ ", k=" +k);
merusak ;
}
merusak ;
}
mencoba {
Thread.tidur(100);
} tangkapan (InterruptedException e) {
e.printStackTrace();
}
}
}
}
Cara lain adalah dengan mengimplementasikan antrian prioritas yang sangat kuat dengan mewarisi PriorityQueue dan mengimplementasikan antarmuka Comparable, lalu menulis ulang sendiri metode CompareTo. Namun, kelemahannya adalah metode ini tidak aman untuk thread!
Kodenya adalah sebagai berikut:
tes paket;
impor java.util.PriorityQueue;
PriorityTest kelas publik memperluas PriorityQueue<PriorityTest.Test>{
pengujian kelas statis mengimplementasikan Comparable<Test>{
Paket tali;
dalam kebanggaan;
Tes publik(Paket string, int kebanggaan) {
ini .paket = paket;
ini .priotity = prioritas;
}
public int bandingkanTo(Uji arg) {
if (prioritas <arg.priotitas)
kembali 1;
else if (priotitas > arg.priotitas)
kembali - 1 ;
kalau tidak
kembali 0;
}
String publik keString(){
paket pengembalian;
}
}
public void add(String str, prioritas int){
super .add( Tes baru(str,prioritas));
}
public static void main(String args[]){
Uji Prioritas pTest = Uji Prioritas baru();
pTest.add( "aaa" , 3 ); //Prioritas tertinggi
pTest.tambahkan( "bbb" , 2 );
pTest.tambahkan( "ccc", 1 );
while (!pTest.isEmpty()){
Sistem.keluar.println(pTest.remove());
}
}