Konsep Multithreading Bahagian Kebuntuan

Selamat datang ke Bahagian 3 siri multithreading kami!

• Dalam Bahagian 1, kami meneroka Atomicity dan Immutability.
• Dalam Bahagian 2, kami membincangkan Kebuluran.

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.

Menavigasi Landasan Kompleks Concurrency

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.

1. Apakah Deadlock?

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.

2. Syarat untuk Deadlock

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,

• Benang A memegang Sumber 1 dan menunggu Sumber 2
• Semasa Thread B memegang Sumber 2 dan menunggu Sumber 1

Kesemua empat syarat yang dikongsi di atas untuk kebuntuan ada, yang mengakibatkan sekatan tidak tentu. Memecahkan mana-mana satu daripadanya boleh mengelakkan kebuntuan.

3. Mengesan / Memantau kebuntuan

Mengesan kebuntuan, terutamanya dalam aplikasi berskala besar, boleh menjadi mencabar. Walau bagaimanapun, pendekatan berikut boleh membantu mengenal pasti kebuntuan

• Peralatan: JConsole, VisualVM dan penganalisis benang Java dalam IDE boleh mengesan kebuntuan dalam masa nyata.
• Pembuangan Benang dan Log: Menganalisis pembuangan benang boleh mendedahkan benang yang menunggu dan sumber yang mereka pegang.

Untuk gambaran keseluruhan terperinci untuk memahami cara menyahpepijat/memantau kebuntuan sila lawati Nyahpepijat dan Pantau Deadlock menggunakan VisualVM dan jstack

4. Strategi untuk Pencegahan Kebuntuan

• 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();
    }
}

• Pemesanan dan Pengeluaran Kunci Tetapkan perintah global yang ketat untuk pemerolehan kunci. Jika semua benang memperoleh kunci dalam susunan yang konsisten, kebergantungan kitaran kurang berkemungkinan terbentuk, sekali gus mengelakkan kebuntuan. Contohnya, sentiasa dapatkan lock1 sebelum lock2 di seluruh pangkalan kod. Amalan ini boleh mencabar dalam aplikasi yang lebih besar tetapi sangat berkesan dalam mengurangkan risiko kebuntuan.

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

Pengambilan Utama untuk Jurutera Perisian

• Setiap kali anda mencipta reka bentuk yang memerlukan penguncian, anda membuka kemungkinan untuk menemui jalan buntu.
• Kebuntuan ialah isu penyekatan yang disebabkan oleh kitaran kebergantungan antara proses. Tiada proses boleh membuat kemajuan kerana masing-masing sedang menunggu sumber yang dipegang oleh yang lain dan tiada yang boleh meneruskan untuk mengeluarkan sumber.
• Kebuntuan lebih teruk, kerana ia menghentikan sepenuhnya proses yang terlibat dan memerlukan memecahkan kitaran kebuntuan untuk pemulihan.
• Kebuntuan boleh berlaku hanya apabila terdapat dua kunci berbeza, iaitu apabila anda memegang kunci dan menunggu kunci lain dilepaskan. (Walau bagaimanapun, terdapat lebih banyak syarat mengenai kebuntuan).
• Keselamatan benang tidak bermakna bebas kebuntuan. Ia hanya menjamin bahawa kod akan beroperasi mengikut antara mukanya, walaupun dipanggil daripada berbilang benang. Membuat thread-safe kelas biasanya termasuk menambah kunci untuk menjamin pelaksanaan selamat.

Outro

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!

Rujukan

• Limpahan timbunan
• Infografik
• Cara untuk mengesan dan membetulkan kebuntuan

Atas ialah kandungan terperinci Konsep Multithreading Bahagian Kebuntuan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!