Bagaimana untuk menyelesaikan masalah penyegerakan benang dan pengecualian bersama di Jawa

Bagaimana untuk menyelesaikan masalah penyegerakan benang dan pengecualian bersama dalam Java

Dalam pengaturcaraan berbilang benang Java, penyegerakan benang dan pengecualian bersama adalah satu tugas yang sangat penting. Tujuan penyegerakan benang adalah untuk memastikan berbilang benang dilaksanakan dalam susunan tertentu, manakala pengecualian bersama benang memastikan berbilang benang tidak mengakses atau mengubah suai sumber dikongsi pada masa yang sama. Mengendalikan isu penyegerakan benang dan pengecualian bersama dengan betul boleh mengelakkan banyak isu keselamatan benang dan meningkatkan prestasi dan kebolehpercayaan program.

Berikut akan memperkenalkan beberapa kaedah yang biasa digunakan untuk menyelesaikan masalah penyegerakan benang dan pengecualian bersama, dan memberikan contoh kod yang sepadan.

1 Gunakan kata kunci yang disegerakkan untuk mencapai penyegerakan benang

Kata kunci yang disegerakkan dalam Java boleh digunakan untuk mengubah suai kaedah atau blok kod untuk mencapai penyegerakan benang. Apabila benang memasuki kaedah diubah suai disegerakkan atau blok kod, ia memperoleh kunci objek yang sepadan, dan utas lain perlu menunggu kunci dilepaskan sebelum ia boleh meneruskan pelaksanaan. Berikut ialah contoh menggunakan kata kunci yang disegerakkan untuk mencapai penyegerakan benang:

public class SynchronizedExample {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();
        
        // 创建两个线程并发执行
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        
        thread1.start();
        thread2.start();
        
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Count: " + example.getCount());
    }
}

Dalam contoh di atas, kata kunci yang disegerakkan digunakan untuk mengubah suai kaedah increment() dan getCount() untuk memastikan kiraan pembolehubah ditingkatkan dan operasi Baca adalah selamat untuk benang. Menjalankan program akan mengeluarkan Count: 2000, menunjukkan bahawa operasi kenaikan dua benang pada pembolehubah kiraan disegerakkan dengan betul.

2. Gunakan antara muka Lock and Condition untuk mencapai penyegerakan benang

Selain menggunakan kata kunci yang disegerakkan, Java juga menyediakan antara muka Kunci dan Keadaan untuk mencapai penyegerakan benang. Berbanding dengan kata kunci yang disegerakkan, antara muka Kunci dan Keadaan menyediakan kawalan yang lebih halus dan boleh mencapai penyegerakan benang dengan lebih fleksibel. Berikut ialah contoh menggunakan antara muka Kunci dan Syarat untuk melaksanakan penyegerakan benang:

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    
    public void increment() {
        lock.lock();
        try {
            count++;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }
    
    public int getCount() {
        lock.lock();
        try {
            while (count < 1000) {
                condition.await();
            }
            return count;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return -1;
    }
}

public class Main {
    public static void main(String[] args) {
        LockExample example = new LockExample();
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        
        thread1.start();
        thread2.start();
        
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Count: " + example.getCount());
    }
}

Dalam contoh di atas, antara muka Kunci dan Syarat digunakan untuk melaksanakan operasi penyegerakan pada pembolehubah kiraan. Dapatkan dan lepaskan kunci dengan memanggil kaedah lock() dan buka kunci(), dan tunggu dan bangunkan benang dengan memanggil kaedah await() dan signalAll(). Menjalankan program akan mengeluarkan Count: 2000, menunjukkan bahawa operasi kenaikan dua benang pada pembolehubah kiraan disegerakkan dengan betul.

Ringkasan

Terdapat banyak penyelesaian untuk masalah penyegerakan benang dan pengecualian bersama dalam Java Artikel ini memperkenalkan penggunaan kata kunci yang disegerakkan dan antara muka Kunci dan Syarat untuk mencapai penyegerakan benang . Apabila menggunakan kaedah ini, anda perlu mematuhi prinsip berikut:

1. Cuba gunakan cara paling mudah untuk mencapai penyegerakan benang, seperti menggunakan kata kunci yang disegerakkan. Pertimbangkan untuk menggunakan antara muka Kunci dan Keadaan hanya apabila kawalan yang lebih terperinci diperlukan.
2. Apabila menggunakan kata kunci yang disegerakkan, cuba gunakan kunci peringkat objek dan bukannya kunci peringkat kelas untuk mengelakkan overhed prestasi yang tidak perlu.
3. Apabila menggunakan antara muka Kunci dan Keadaan, pastikan anda ingat untuk melepaskan kunci dalam blok akhirnya untuk memastikan kunci dilepaskan.

Dengan mengendalikan penyegerakan benang dan isu pengecualian bersama dengan betul, kami boleh mengelakkan banyak isu keselamatan benang yang berpotensi dan memastikan ketepatan dan kebolehpercayaan program. Pada masa yang sama, ia juga boleh meningkatkan prestasi dan keupayaan serentak program, menggunakan sepenuhnya sumber perkakasan pada pemproses berbilang teras, dan meningkatkan kecekapan pelaksanaan program.

Atas ialah kandungan terperinci Bagaimana untuk menyelesaikan masalah penyegerakan benang dan pengecualian bersama di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!