Rumah >Java >javaTutorial >Konsep Multithreading Bahagian Kebuntuan
Selamat datang ke Bahagian 3 siri multithreading kami!
Dalam bahagian ini, kita akan menyelami mekanik Kebuntuan dalam multithreading. Apa yang menyebabkannya, Bagaimana untuk mengenal pasti dan strategi pencegahan yang boleh anda gunakan untuk mengelakkan mengubah kod anda menjadi persimpangan terkunci. Aplikasi terhenti, selalunya tanpa sebarang ralat yang boleh dilihat, menyebabkan pembangun bingung dan sistem beku.
Analogi berguna untuk memahami kebuntuan ialah membayangkan rangkaian kereta api dengan berbilang kereta api di landasan bersilang.
Memandangkan setiap kereta api sedang menunggu yang seterusnya untuk bergerak, tiada siapa yang boleh meneruskan, membawa kepada jalan buntu. Dalam senario ini, sistem isyarat yang tidak cekap membenarkan setiap kereta api memasuki bahagian masing-masing tanpa terlebih dahulu mengesahkan bahawa bahagian seterusnya akan bebas, memerangkap semua kereta api dalam kitaran yang tidak boleh dipecahkan.
Contoh kereta api ini menggambarkan kebuntuan biasa dalam multithreading, di mana benang (seperti kereta api) memegang sumber (bahagian trek) sementara menunggu sumber lain dibebaskan, tetapi tiada satu pun boleh maju. Untuk mengelakkan kebuntuan dalam perisian seperti ini, strategi pengurusan sumber yang berkesan—serupa dengan isyarat kereta api yang lebih pintar—mesti dilaksanakan untuk mengelakkan pergantungan bulat dan memastikan laluan selamat untuk setiap rangkaian.
Kebuntuan ialah situasi di mana utas (atau proses) disekat selama-lamanya, menunggu sumber yang dipegang oleh utas lain. Senario ini membawa kepada kitaran kebergantungan yang tidak boleh dipecahkan, di mana tiada benang yang terlibat boleh membuat kemajuan. Memahami asas kebuntuan adalah penting sebelum meneroka kaedah pengesanan, pencegahan dan penyelesaian.
Untuk kebuntuan berlaku, empat syarat mesti dipenuhi serentak, dikenali sebagai syarat Coffman:
Pengecualian Bersama: Sekurang-kurangnya satu sumber mesti disimpan dalam mod tidak boleh kongsi, bermakna hanya satu urutan boleh menggunakannya pada satu-satu masa.
Tahan dan Tunggu: Utas mesti memuatkan satu sumber dan menunggu untuk memperoleh sumber tambahan yang ada pada urutan lain.
Tiada Preemption: Sumber tidak boleh diambil secara paksa daripada benang. Mereka mesti dibebaskan secara sukarela.
Tunggu Pekeliling: Rangkaian rangkaian tertutup wujud, di mana setiap utas mengandungi sekurang-kurangnya satu sumber yang diperlukan oleh urutan seterusnya dalam rantai.
Mari kita fahami sebagai rajah jujukan
Dalam animasi di atas,
Kesemua empat syarat yang dikongsi di atas untuk kebuntuan ada, yang mengakibatkan sekatan tidak tentu. Memecahkan mana-mana satu daripadanya boleh mengelakkan kebuntuan.
Mengesan kebuntuan, terutamanya dalam aplikasi berskala besar, boleh menjadi mencabar. Walau bagaimanapun, pendekatan berikut boleh membantu mengenal pasti kebuntuan
Untuk gambaran keseluruhan terperinci untuk memahami cara menyahpepijat/memantau kebuntuan sila lawati Nyahpepijat dan Pantau Deadlock menggunakan VisualVM dan jstack
Menggunakan Skim Tunggu-Mati dan Luka-Tunggu
Skim Tunggu-Mati: Apabila utas meminta kunci dipegang oleh utas lain, pangkalan data menilai keutamaan relatif (biasanya berdasarkan cap waktu setiap utas). Jika urutan permintaan mempunyai keutamaan yang lebih tinggi, ia menunggu; jika tidak, ia mati (dimulakan semula).
Skim Luka-Tunggu: Jika benang yang meminta mempunyai keutamaan yang lebih tinggi, ia meluka (mendahului) benang keutamaan yang lebih rendah dengan memaksanya melepaskan kunci.
Objek Tak Berubah untuk Keadaan Dikongsi
Reka bentuk keadaan kongsi sebagai tidak berubah di mana mungkin. Memandangkan objek tidak boleh ubah tidak boleh diubah suai, mereka memerlukan tiada kunci untuk akses serentak, mengurangkan risiko kebuntuan dan memudahkan kod.
Menggunakan tryLock dengan Tamat Masa untuk Pemerolehan Kunci: Tidak seperti blok disegerakkan standard, ReentrantLock membenarkan penggunaan tryLock(masa tamat, unit) untuk mencuba memperoleh kunci dalam tempoh yang ditetapkan. Jika kunci tidak diperoleh dalam masa itu, kunci itu mengeluarkan sumber, menghalang sekatan tanpa had.
ReentrantLock lock1 = new ReentrantLock(); ReentrantLock lock2 = new ReentrantLock(); public void acquireLocks() { try { if (lock1.tryLock(100, TimeUnit.MILLISECONDS)) { try { if (lock2.tryLock(100, TimeUnit.MILLISECONDS)) { // Critical section } } finally { lock2.unlock(); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { lock1.unlock(); } }
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class LockOrderingExample { private static final Lock lock1 = new ReentrantLock(); private static final Lock lock2 = new ReentrantLock(); public static void main(String[] args) { Thread thread1 = new Thread(() -> { acquireLocksInOrder(lock1, lock2); }); Thread thread2 = new Thread(() -> { acquireLocksInOrder(lock1, lock2); }); thread1.start(); thread2.start(); } private static void acquireLocksInOrder(Lock firstLock, Lock secondLock) { try { firstLock.lock(); System.out.println(Thread.currentThread().getName() + " acquired lock1"); secondLock.lock(); System.out.println(Thread.currentThread().getName() + " acquired lock2"); // Perform some operations } finally { secondLock.unlock(); System.out.println(Thread.currentThread().getName() + " released lock2"); firstLock.unlock(); System.out.println(Thread.currentThread().getName() + " released lock1"); } } }
Gunakan Thread-Safe/Concurrent Collections: Pakej java.util.concurrent Java menyediakan pelaksanaan selamat benang bagi struktur data biasa (ConcurrentHashMap, CopyOnWriteArrayList, dll.) yang mengendalikan penyegerakan secara dalaman, mengurangkan keperluan untuk kunci yang jelas. Koleksi ini meminimumkan kebuntuan kerana ia direka untuk mengelakkan keperluan penguncian eksplisit, menggunakan teknik seperti pembahagian dalaman.
Elakkan Kunci Bersarang
Minimumkan memperoleh berbilang kunci dalam blok yang sama untuk mengelakkan kebergantungan bulat. Jika kunci bersarang diperlukan, gunakan pesanan kunci yang konsisten
Sama ada anda seorang pemula atau pembangun yang berpengalaman, memahami kebuntuan adalah penting untuk menulis kod yang mantap dan cekap dalam sistem serentak. Dalam artikel ini, kami meneroka apakah kebuntuan, puncanya, dan cara praktikal untuk mencegahnya. Dengan melaksanakan strategi peruntukan sumber yang berkesan, menganalisis kebergantungan tugas dan menggunakan alatan seperti longgokan benang dan alat pengesan jalan buntu, pembangun boleh meminimumkan risiko kebuntuan dan mengoptimumkan kod mereka untuk keselarasan yang lancar.
Sambil kami meneruskan perjalanan melalui konsep teras multithreading, nantikan artikel seterusnya dalam siri ini. Kami akan menyelami Bahagian Kritikal, memahami cara mengurus sumber yang dikongsi dengan selamat antara berbilang urutan. Kami juga akan membincangkan konsep Keadaan Perlumbaan, isu bersamaan biasa yang boleh membawa kepada tingkah laku dan pepijat yang tidak dapat diramalkan jika dibiarkan.
Dengan setiap langkah, anda akan mendapat cerapan yang lebih mendalam tentang cara menjadikan aplikasi anda selamat, cekap dan berdaya tahan. Teruskan menolak sempadan pengetahuan multithreading anda untuk membina perisian yang lebih baik dan lebih berprestasi!
Atas ialah kandungan terperinci Konsep Multithreading Bahagian Kebuntuan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!