Kaedah pelaksanaan penyegerakan benang dan pengecualian bersama dalam bahasa Java

Bahasa Java ialah bahasa yang memperkenalkan multi-threading pada zaman awal Penggunaan benang menjadikan bahasa Java bersinar dalam pemprosesan program serentak. Walau bagaimanapun, isu penyegerakan dan isu pengecualian bersama antara benang sentiasa menjadi kunci kepada proses pengaturcaraan. Dalam bahasa Java, terdapat banyak cara untuk melaksanakan penyegerakan benang dan pengecualian bersama Artikel ini akan memperkenalkan beberapa daripadanya.

1. Gunakan kata kunci disegerakkan untuk mencapai penyegerakan dan pengecualian bersama

Disegerakkan ialah cara paling asas untuk mencapai penyegerakan dan pengecualian bersama dalam bahasa Java. Di Java, setiap objek mempunyai monitor Apabila utas memasuki blok kod monitor, ia memperoleh kunci objek, dan utas lain yang perlu melaksanakan blok kod kunci hanya boleh menunggu. Apabila satu utas menyelesaikan pelaksanaan, kunci objek dilepaskan, dan utas lain yang menunggu objek boleh memasuki blok kod dan mengulangi proses di atas.

Pelaksanaan menggunakan synchronized agak mudah, cuma tambah kata kunci yang disegerakkan sebelum kaedah atau blok kod yang perlu disegerakkan. Contohnya:

public synchronized void method1(){
  //...
}

Atau menggunakan blok kod:

public void method1(){
  synchronized(this) {
    //...
  }
}

Satu lagi bentuk penyegerakan ialah penguncian kelas. Apabila menggunakan kunci kelas, monitor ialah objek Kelas daripada kelas yang sama. Contohnya:

public class MyClass {
  public static synchronized void method1(){
    //...
  }
}

Dalam kod di atas, semua kejadian MyClass berkongsi objek Kelas yang sama bagi kelas MyClass.

2. Gunakan ReentrantLock untuk melaksanakan penyegerakan dan pengecualian bersama

Tidak seperti kata kunci yang disegerakkan, ReentrantLock ialah kelas dan bukannya kata kunci. ReentrantLock mempunyai fungsi yang serupa dengan disegerakkan, tetapi menyediakan kawalan penyegerakan dan mekanisme pengecualian bersama yang lebih berkuasa. Sebaliknya, penggunaan ReentrantLock adalah lebih fleksibel, contohnya, ia boleh mencapai pemerolehan kunci yang adil, mengira bilangan pemerolehan kunci oleh benang, dsb.

Penggunaan ReentrantLock adalah seperti berikut:

ReentrantLock lock = new ReentrantLock();
lock.lock();
try{
  //...
} finally {
  lock.unlock();
}

ReentrantLock ialah reentrant, iaitu benang yang sama boleh mendapatkan kunci beberapa kali.

3. Gunakan CountDownLatch untuk mencapai penyegerakan

CountDownLatch ialah kelas alat untuk penyegerakan utas, yang membenarkan satu atau lebih utas menunggu sehingga satu lagi atau lebih utas selesai pelaksanaan. CountDownLatch menyediakan pembilang undur Urutan yang perlu menunggu perlu memanggil kaedah Countdown() untuk mengurangkan pembilang sebanyak 1. Apabila pembilang ialah 0, utas menunggu boleh terus dilaksanakan.

Menggunakan CountDownLatch membolehkan satu utas menunggu untuk urutan lain bermula sebelum meneruskan. Contohnya:

//初始化计数器为1
CountDownLatch latch = new CountDownLatch(1);

//线程1
new Thread(new Runnable() {
  public void run(){
    //其他操作
    latch.countDown();
  }
}).start();

//线程2等待线程1启动完毕
latch.await();

//线程2继续执行

4. Gunakan Semaphore untuk melaksanakan penyegerakan dan pengecualian bersama

Semaphore ialah satu lagi kelas alat serentak Java yang membolehkan anda mengawal bilangan utas yang mengakses sumber tertentu secara serentak. Semaphore mengekalkan set lesen Apabila thread meminta lesen, ia boleh menerima lesen dan meneruskan pelaksanaan. Apabila lesen habis, anda perlu menunggu benang lain mengembalikan lesen sebelum meneruskan.

Gunakan Semaphore untuk mengehadkan bilangan utas yang mengakses sumber pada masa yang sama, contohnya:

//初始化Semaphore，设定同时允许2个线程访问
Semaphore semaphore = new Semaphore(2);

//其他线程请求许可证
semaphore.acquire();

//许可证使用完毕后释放
semaphore.release();

Ringkasan:

Di atas adalah beberapa cara untuk melaksanakan penyegerakan utas dan pengecualian bersama dalam kaedah bahasa Java, yang disegerakkan adalah kaedah pelaksanaan paling asas, ReentrantLock menyediakan mekanisme kawalan yang lebih berkuasa, dan CountDownLatch dan Semaphore boleh mengawal kerjasama dan keselarasan antara utas dengan baik. Dalam pengaturcaraan sebenar, pemilihan munasabah dan penggunaan alat ini yang fleksibel boleh mengelakkan penyegerakan benang dan masalah pengecualian bersama dalam program Java.

Atas ialah kandungan terperinci Kaedah pelaksanaan penyegerakan benang dan pengecualian bersama dalam bahasa Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!