Bagaimana untuk mencapai penyegerakan benang menggunakan mekanisme kunci di Jawa?

Bagaimana untuk menggunakan mekanisme kunci dalam Java untuk mencapai penyegerakan benang?

Dalam pengaturcaraan berbilang benang, penyegerakan benang adalah konsep yang sangat penting. Apabila berbilang rangkaian mengakses dan mengubah suai sumber dikongsi pada masa yang sama, ketidakkonsistenan data atau keadaan perlumbaan mungkin berlaku. Java menyediakan mekanisme penguncian untuk menyelesaikan masalah ini dan memastikan akses selamat benang kepada sumber yang dikongsi.

Mekanisme penguncian dalam Java disediakan oleh kata kunci yang disegerakkan dan antara muka Kunci. Seterusnya, kita akan belajar cara menggunakan kedua-dua mekanisme ini untuk mencapai penyegerakan benang.

Contoh menggunakan kata kunci yang disegerakkan untuk melaksanakan penyegerakan benang:

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

class IncrementThread extends Thread {
    private Counter counter;

    public IncrementThread(Counter counter) {
        this.counter = counter;
    }

    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }
}

public class SynchronizedExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        IncrementThread thread1 = new IncrementThread(counter);
        IncrementThread thread2 = new IncrementThread(counter);

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final count: " + counter.getCount());
    }
}

Dalam contoh di atas, kelas Counter mempunyai pembolehubah kiraan untuk mewakili nilai pembilang. Kaedah increment() diubah suai dengan kata kunci yang disegerakkan, yang bermaksud hanya satu utas boleh mengakses dan mengubah suai pembolehubah kiraan pada bila-bila masa. Kaedah getCount() juga diubah suai dengan kata kunci yang disegerakkan untuk memastikan keselamatan benang apabila mendapatkan nilai pembilang.

Kelas IncrementThread ialah kelas thread yang menerima objek Counter sebagai parameter pembina dan memanggil kaedah increment() dalam kaedah run() untuk meningkatkan nilai counter.

Dalam program utama, kami mencipta dua utas IncrementThread dan menghantarnya kepada dua kejadian utas masing-masing. Kami kemudian memulakan kedua-dua utas ini dan menunggu mereka selesai menggunakan kaedah join(). Akhir sekali, kami mencetak nilai pembilang akhir.

Contoh penggunaan antara muka Lock untuk melaksanakan penyegerakan benang:

class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

class IncrementThread extends Thread {
    private Counter counter;

    public IncrementThread(Counter counter) {
        this.counter = counter;
    }

    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }
}

public class LockExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        IncrementThread thread1 = new IncrementThread(counter);
        IncrementThread thread2 = new IncrementThread(counter);

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final count: " + counter.getCount());
    }
}

Dalam contoh di atas, antara muka Lock digunakan dalam kaedah increment() dan getCount() kelas Counter untuk melaksanakan penyegerakan benang. Kami mencipta contoh ReentrantLock untuk memperoleh dan melepaskan kunci pada permulaan dan akhir kaedah masing-masing.

Kod untuk kelas IncrementThread dan program utama adalah sama seperti dalam contoh sebelumnya. Hanya gunakan antara muka Kunci dan bukannya kata kunci yang disegerakkan dalam kelas Kaunter untuk mencapai penyegerakan benang.

Ringkasan:

Dalam pengaturcaraan berbilang benang, penyegerakan benang ialah konsep penting. Java menyediakan kata kunci yang disegerakkan dan antara muka Kunci untuk mencapai penyegerakan benang. Tidak kira mekanisme yang digunakan, ia boleh dijamin bahawa hanya satu utas boleh mengakses dan mengubah suai sumber yang dikongsi pada bila-bila masa, dengan itu memastikan akses selamat benang.

Di atas ialah kod sampel untuk menggunakan mekanisme kunci dalam Java untuk mencapai penyegerakan benang. Dengan memahami dan mengkaji contoh ini, kami boleh menggunakan penyegerakan benang dengan lebih baik untuk memastikan ketepatan dan prestasi program berbilang benang.

Atas ialah kandungan terperinci Bagaimana untuk mencapai penyegerakan benang menggunakan mekanisme kunci di Jawa?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!