Cara menangani pengecualian penyegerakan kemas kini data serentak dalam pembangunan Java

Cara menangani pengecualian penyegerakan kemas kini data serentak dalam pembangunan Java

Dalam pembangunan Java, kadangkala kita memerlukan berbilang rangkaian untuk mengendalikan data yang dikongsi pada masa yang sama. Walau bagaimanapun, masalah konkurensi boleh timbul apabila berbilang rangkaian mengemas kini data kongsi pada masa yang sama. Contohnya, jika satu utas sedang membaca data yang dikongsi manakala satu lagi urutan sedang menulis pada masa yang sama, ini boleh membawa kepada ketidakkonsistenan data dengan mudah atau malah pengecualian yang tidak dijangka.

Untuk menyelesaikan masalah ini, Java menyediakan beberapa mekanisme untuk mengendalikan pengecualian penyegerakan kemas kini data serentak Kami boleh menggunakan mekanisme ini untuk memastikan bahawa operasi pada data yang dikongsi antara urutan adalah selamat dan teratur.

1. Gunakan kata kunci yang disegerakkan
Kata kunci yang disegerakkan boleh digunakan untuk mengubah suai kaedah atau blok kod. Apabila benang memasuki kaedah atau blok kod yang diubah suai dengan disegerakkan, ia secara automatik memperoleh kunci objek dan benang lain mesti menunggu benang melepaskan kunci sebelum ia boleh meneruskan pelaksanaan. Ini memastikan bahawa operasi pada data yang dikongsi oleh berbilang rangkaian adalah saling eksklusif, dengan itu mengelakkan masalah konkurensi.

Sebagai contoh, kod berikut menunjukkan cara menggunakan kata kunci yang disegerakkan untuk memastikan keselamatan benang:

public class Counter {
    private int count = 0;

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

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

Dalam contoh ini, kaedah increment() dan getCount() dalam kelas Counter kedua-duanya diubah suai secara disegerakkan, sekali gus memastikan berbilang Thread operasi pada pembolehubah kiraan adalah saling eksklusif.

2. Gunakan Kunci
Selain kata kunci yang disegerakkan, Java juga menyediakan mekanisme kunci yang lebih fleksibel - Kunci. Lock ialah mekanisme penyegerakan dalam pakej Java.util.concurrent yang membenarkan kawalan yang lebih terperinci bagi capaian benang kepada data kongsi.

Berbanding dengan kata kunci yang disegerakkan, Lock mempunyai kebolehskalaan dan fleksibiliti yang lebih baik. Ia menyediakan lebih banyak ciri seperti kemasukan semula, menunggu bersyarat dan menunggu tamat masa. Dengan Lock, kami boleh mengawal capaian benang kepada data yang dikongsi dengan lebih tepat, dengan itu mengurangkan berlakunya masalah konkurensi.

Berikut ialah contoh kod untuk menggunakan kunci Kunci:

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

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

Dalam contoh ini, kami mencipta objek ReentrantLock dan menggunakan kaedah lock() untuk memperoleh kunci dan kaedah buka kunci() untuk melepaskan kunci. Dengan menggunakan Lock, kami boleh mengawal akses sumber dengan lebih tepat dan memastikan keselamatan benang.

3. Gunakan struktur data selamat benang
Cara lain untuk menangani pengecualian penyegerakan dalam kemas kini data serentak ialah menggunakan struktur data selamat benang. Java menyediakan banyak struktur data selamat benang, seperti Vektor, Hashtable, ConcurrentHashMap, dsb. Struktur data ini secara semula jadi selamat untuk benang dan boleh mengelakkan isu konkurensi.

Untuk situasi di mana data perlu dikemas kini dengan kerap, kami boleh mempertimbangkan untuk menggunakan kelas pengumpulan selamat benang. Sebagai contoh, kelas ConcurrentHashMap disediakan dalam pakej Java.util.concurrent, yang merupakan pelaksanaan jadual cincang selamat benang yang boleh melaksanakan operasi baca dan tulis serentak dalam persekitaran serentak tinggi.

Berikut ialah contoh kod menggunakan kelas ConcurrentHashMap:

import java.util.concurrent.ConcurrentHashMap;

public class Counter {
    private ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

    public void increment(String key) {
        map.putIfAbsent(key, 0);
        map.compute(key, (k, v) -> v + 1);
    }

    public int getCount(String key) {
        return map.getOrDefault(key, 0);
    }
}

Dalam contoh ini, kami menggunakan ConcurrentHashMap untuk menyimpan pembilang, menambah pasangan nilai kunci melalui kaedah putIfAbsent() dan mengumpul nilai menggunakan pengiraan( ) kaedah. Memandangkan ConcurrentHashMap selamat untuk thread, kami tidak perlu risau tentang isu konkurensi.

Ringkasan:
Dalam pembangunan Java, adalah sangat penting untuk menangani pengecualian penyegerakan kemas kini data serentak. Kita boleh menggunakan kata kunci yang disegerakkan, Kunci atau struktur data selamat benang untuk memastikan keselamatan benang. Kata kunci yang disegerakkan sesuai untuk situasi mudah, Kunci sesuai untuk situasi yang kompleks, dan struktur data selamat benang sesuai untuk situasi di mana data kerap dikemas kini. Pemilihan mekanisme yang bersesuaian yang munasabah dapat meningkatkan prestasi konkurensi program dan mengelakkan berlakunya masalah konkurensi.

Atas ialah kandungan terperinci Cara menangani pengecualian penyegerakan kemas kini data serentak dalam pembangunan Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!