Antara muka kunci menyediakan kawalan kunci yang lebih fleksibel daripada disegerakkan, pengambilalihan percubaan, gangguan, pengambilalihan masa tamat dan kunci yang adil; 2. Keadaan membolehkan komunikasi inter-thread yang tepat melalui pembolehubah pelbagai keadaan untuk mengelakkan bangun palsu; 3. Penyegerakan biasa termasuk CountDownLatch untuk menunggu pelbagai tugas untuk diselesaikan, CyclicBarrier untuk penyegerakan multi-thread untuk mencapai titik halangan, semaphore untuk mengawal bilangan benang serentak, dan phaser untuk penyegerakan bertahap benang dinamik; Apabila menggunakannya, kesederhanaan disegerakkan mesti diberi keutamaan. Kunci mesti menggabungkan percubaan-finally untuk mengelakkan kebuntuan, keadaan harus digunakan dengan sementara, dan alat penyegerakan yang sesuai harus dipilih mengikut tempat kejadian untuk mengelakkan lebih banyak reka bentuk.

Dalam pengaturcaraan serentak Java, walaupun kata kunci synchronized mudah dan mudah digunakan, mereka tidak cukup fleksibel dalam senario yang lebih kompleks. Untuk melakukan ini, Java menyediakan pakej java.util.concurrent.locks , yang mengandungi alat kawalan concurrency yang lebih kuat: kunci, syarat, dan penyegerakan . Mereka membolehkan pemaju mengawal tingkah laku penyegerakan benang lebih halus.

1. Antara muka kunci: mekanisme kunci yang lebih fleksibel daripada disegerakkan

Lock adalah alternatif yang dipertingkatkan untuk synchronized , dengan kelebihan utama:

• Anda boleh cuba memperoleh kunci ( tryLock() ) untuk mengelakkan menyekat
• Boleh mengganggu benang menunggu kunci
• Boleh tamat tempoh untuk memperoleh kunci
• Kawalan kunci yang lebih halus (seperti pemisahan baca dan tulis)

Kelas Pelaksanaan Biasa: ReentrantLock

 Kunci kunci = reentrantLock baru ();

lock.lock ();
Cuba {
    // Sistem Kawasan Kritikal.out.println ("Thread memasuki kawasan kritikal");
} akhirnya {
    lock.unlock (); // mesti diletakkan pada akhirnya untuk mengelakkan kebuntuan}

?? NOTA: Kunci mesti dikeluarkan secara manual, jika tidak, ia akan menyebabkan kebocoran atau kebocoran sumber.

Perbandingan dengan disegerakkan

2. Keadaan: Kawalan tepat komunikasi antara thread

Condition adalah serupa dengan menunggu Object wait() dan notify() , tetapi lebih fleksibel. Lock boleh membuat pelbagai Condition keadaan untuk melaksanakan pelbagai menunggu/pemberitahuan .

Gunakan senario: model pengguna-pengguna

 Kunci kunci = reentrantLock baru ();
Keadaan notFull = lock.newCondition ();
Keadaan notEmpty = lock.newCondition ();

// producer lock.lock ();
Cuba {
    manakala (giliran.size () == kapasiti) {
        notfull.await (); // giliran tunggu tidak berpuas hati}
    giliran.add (item);
    notempty.signal (); // Beritahu pengguna} akhirnya {
    lock.unlock ();
}

// lock.lock pengguna ();
Cuba {
    manakala (giliran.isempty ()) {
        notempty.await (); // tunggu giliran tidak kosong}
    Item rentetan = giliran.poll ();
    notfull.signal (); // Beritahu pengeluar} akhirnya {
    lock.unlock ();
}

? Kelebihan: Pemboleh ubah keadaan berganda boleh dikawal secara bebas untuk mengelakkan gangguan palsu atau gangguan pemberitahuan.

3. Penyegerakan Biasa: Alat Penyegerakan Lanjutan yang disediakan oleh JUC

Java menyediakan beberapa kelas penolong penyegerakan di luar kotak, yang terletak di pakej java.util.concurrent :

① CountDownLatch: Kacang Countdown

Digunakan untuk membuat satu atau lebih benang menunggu benang lain untuk menyelesaikan operasi.

 CountDownLatch Latch = New CountDownLatch (3);

// Thread Worker Latch.CountDown ();

// Tunggu benang Latch.Await (); // blok sehingga kiraan kembali menjadi sifar

? Senario yang berkenaan: Benang utama menunggu pelbagai tugas latar belakang untuk diselesaikan.

② Cyclicbarrier: Pagar Pekeliling

Biarkan sekumpulan benang menunggu satu sama lain sehingga mereka semua mencapai titik penghalang tertentu, dan kemudian terus melaksanakan bersama.

 CyclicBarrier Barrier = CyclicBarrier Baru (3, () -> {
    System.out.println ("Semua benang ada di tempat, mula tindakan!");
});

halangan.Await (); // tunggu selepas setiap utas dipanggil

? Senario yang berkenaan: Pengkomputeran selari pelbagai threaded disegerakkan secara berperingkat, seperti penyediaan data ujian selari.

③ Semaphore: Semaphore, mengawal bilangan serentak

Hadkan bilangan benang yang mengakses sumber pada masa yang sama (seperti kolam sambungan pangkalan data).

 Semaphore Semaphore = Semaphore baru (3); // sehingga 3 benang akses semaphore.acquire (); // Dapatkan kebenaran cuba {
    // melaksanakan operasi terhad} akhirnya {
    semaphore.release (); // melepaskan lesen}

? Skenario yang berkenaan: Pengaturan semasa, Kawalan Kolam Sumber.

④ phaser: penghalang penyegerakan yang lebih fleksibel (maju)

Ia menyokong pendaftaran dinamik benang yang mengambil bahagian, sesuai untuk senario di mana tugas bertahap dan bilangan benang tidak ditetapkan.

Cadangan dan langkah berjaga -jaga untuk digunakan

• Keutamaan untuk menggunakan disegerakkan : Jika adegan mudah, synchronized lebih selamat dan mudah.
• Kunci mesti dilengkapi dengan cuba-finally : Mencegah pengecualian daripada menyebabkan kunci tidak dikeluarkan.
• Elakkan kunci bersarang : Mudah untuk menyebabkan kebuntuan. Jika anda mesti menggunakannya, perhatikan perintah penguncian.
• Keadaan mesti digunakan bersama semasa penghakiman : mencegah kebangkitan palsu.
• Penyegerakan tidak semua tujuan : Pilih alat yang betul dan elakkan daripada merancang.

Pada dasarnya itu sahaja. Alat kesesuaian Java menyediakan pelbagai pilihan dari Lock asas ke Synchronizers peringkat tinggi. Kuncinya adalah untuk memahami senario yang berkenaan setiap mekanisme dan mengelakkan "bersedia menggunakan tetapi salah".

Atas ialah kandungan terperinci Java Concurrency: Kunci, Syarat, dan Penyegerakan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!