Bagaimana untuk menyelesaikan isu perbalahan benang dan perbalahan sumber di Java

Cara menyelesaikan masalah persaingan benang dan pertikaian sumber dalam Java

Dalam pengaturcaraan berbilang benang, isu persaingan benang dan pertikaian sumber adalah perkara biasa jika tidak dikendalikan dengan betul, ia akan membawa kepada masalah keselamatan dan prestasi program. Artikel ini akan memperkenalkan beberapa penyelesaian biasa dan memberikan contoh kod khusus.

1. Gunakan kata kunci yang disegerakkan
Kata kunci yang disegerakkan ialah kaedah paling asas dalam Java untuk menyelesaikan masalah persaingan benang dan pertikaian sumber. Ia boleh menandakan blok kod atau kaedah sebagai disegerakkan supaya hanya satu utas boleh melaksanakannya pada satu masa.

1. Gunakan kata kunci yang disegerakkan untuk mengubah suai kaedah:

public synchronized void synchronizedMethod(){
    // 同步代码块
}

2. Gunakan kata kunci yang disegerakkan untuk mengubah suai blok kod:

public void nonSynchronizedMethod(){
    synchronized (this){
        // 同步代码块
    }
}

Dalam contoh di atas, kata kunci yang disegerakkan menandakan kaedah atau blok kod sebagai menyegerakkan bahawa terdapat penyegerakan hanya satu pada masa yang sama Benang boleh mengaksesnya, dengan itu mengelakkan perbalahan benang dan perbalahan untuk sumber.

2. Gunakan antara muka Lock dan kelas ReentrantLock
Selain kata kunci yang disegerakkan, Java juga menyediakan antara muka Lock dan kelas ReentrantLock untuk menyelesaikan masalah persaingan benang dan pertikaian sumber. Tidak seperti disegerakkan, antara muka Lock dan kelas ReentrantLock memberikan lebih fleksibiliti dan fungsi.

1. Menggunakan antara muka Lock dan kelas ReentrantLock:

Lock lock = new ReentrantLock();

public void synchronizedMethod(){
    lock.lock();
    try{
        // 同步代码块
    }finally{
        lock.unlock();
    }
}

Dalam contoh di atas, objek ReentrantLock pertama kali dicipta, kemudian kaedah lock() digunakan untuk memperoleh kunci, dan kaedah buka kunci() digunakan dalam percubaan -akhirnya kenyataan untuk melepaskan kunci. Ini memastikan bahawa hanya satu utas boleh melaksanakan blok kod disegerakkan pada masa yang sama.

3. Gunakan kelas Semaphore
Jika anda perlu mengawal bilangan utas yang mengakses sumber tertentu pada masa yang sama, anda boleh menggunakan kelas Semaphore untuk menyelesaikan masalah. Kelas Semaphore ialah semaphore mengira yang boleh menentukan berbilang benang untuk mengakses sumber yang dikongsi pada masa yang sama.

1. Menggunakan kelas Semaphore:

Semaphore semaphore = new Semaphore(2); // 允许同时访问的线程数为2

public void synchronizedMethod(){
    try{
        semaphore.acquire(); // 获取许可
        // 同步代码块
    }catch(InterruptedException e){
        // 异常处理
    }finally{
        semaphore.release(); // 释放许可
    }
}

Dalam contoh di atas, objek Semaphore pertama kali dicipta dan bilangan utas yang dibenarkan untuk mengakses secara serentak dinyatakan sebagai 2. Kemudian gunakan kaedah acquire() untuk mendapatkan kebenaran Jika kebenaran tidak tersedia, benang akan disekat sehingga kebenaran tersedia. Akhir sekali, gunakan kaedah release() dalam kenyataan akhirnya untuk melepaskan lesen.

Dengan cara ini, hanya bilangan utas yang ditentukan boleh melaksanakan blok kod disegerakkan pada masa yang sama, dan utas lain perlu menunggu kebenaran untuk masuk.

4. Gunakan antara muka Keadaan dan kelas ReentrantLock
Antara muka keadaan dan kelas ReentrantLock boleh digunakan bersama untuk mengawal persaingan benang dan isu perbalahan sumber dengan lebih fleksibel. Antara muka Keadaan menyediakan kaedah seperti await() dan signal() untuk melaksanakan operasi menunggu benang dan bangun.

1. Menggunakan antara muka Keadaan dan kelas ReentrantLock:

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

public void waitMethod(){
    lock.lock();
    try{
        while(conditionFlag){
            condition.await(); // 线程等待
        }
        // 同步代码块
    }catch(InterruptedException e){
        // 异常处理
    }finally{
        lock.unlock();
    }
}

public void signalMethod(){
    lock.lock();
    try{
        conditionFlag = false;
        condition.signal(); // 唤醒线程
    }finally{
        lock.unlock();
    }
}

Dalam contoh di atas, objek ReentrantLock dan objek Keadaan mula-mula dicipta. Dalam kaedah waitMethod(), gunakan kaedah lock() untuk memperoleh kunci dan gunakan kaedah await() dalam gelung while untuk membuat benang menunggu sehingga conditionFlag adalah palsu. Dalam kaedah signalMethod(), gunakan kaedah lock() untuk memperoleh kunci, tetapkan conditionFlag kepada false dan gunakan kaedah signal() untuk membangkitkan benang.

Dengan cara ini, operasi menunggu benang dan bangun tidur dapat direalisasikan, dengan itu mengawal persaingan benang dan isu perbalahan sumber.

Ringkasan
Isu persaingan benang dan pertikaian sumber sering dihadapi dalam pengaturcaraan berbilang benang, dan penyelesaian yang sesuai perlu diguna pakai untuk memastikan keselamatan dan prestasi program. Artikel ini memperkenalkan penggunaan kata kunci yang disegerakkan, antara muka Lock dan kelas ReentrantLock, kelas Semaphore, antara muka Keadaan dan kelas ReentrantLock untuk menyelesaikan masalah persaingan benang dan pertikaian sumber serta menyediakan contoh kod yang sepadan. Saya berharap pembaca dapat memilih kaedah yang sesuai untuk menyelesaikan masalah berdasarkan keperluan sebenar.

Atas ialah kandungan terperinci Bagaimana untuk menyelesaikan isu perbalahan benang dan perbalahan sumber di Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!