Pengenalan kepada idea pelaksanaan keselamatan benang dalam Java

Dalam pengaturcaraan berbilang benang Java, keselamatan benang ialah konsep yang sangat penting. Program yang mengekalkan tingkah laku yang betul apabila berbilang benang dilaksanakan serentak dikatakan selamat untuk benang. Dalam artikel ini, kami akan memperkenalkan beberapa idea pelaksanaan biasa yang boleh memastikan keselamatan benang di Jawa. . Kata kunci yang disegerakkan boleh digunakan untuk mengubah suai kaedah contoh, kaedah statik dan blok kod. Ini ialah kod contoh kaedah contoh, diubah suai dengan disegerakkan

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

Dalam kod di atas, kaedah increment() dan getCount() kedua-duanya diubah suai dengan segerak, yang memastikan hanya satu utas boleh mengaksesnya pada satu masa. Walaupun kaedah ini mudah, ia agak tidak cekap kerana hanya satu utas dibenarkan untuk mengakses kaedah ini pada satu masa.

2. Gunakan kelas ReentrantLock

Kelas ReentrantLock di Java menyediakan mekanisme penyegerakan benang yang lebih fleksibel daripada disegerakkan. ReentrantLock ialah reentrant, boleh mengganggu urutan menunggu kunci, dan boleh cuba mendapatkan kunci melalui kaedah tryLock(). Berikut ialah contoh kod untuk mencapai keselamatan benang dengan menggunakan ReentrantLock:

import java.util.concurrent.locks.ReentrantLock;
public class Counter {
    private int count;
    private ReentrantLock 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 kod di atas, kunci diperoleh dengan memanggil kaedah lock.lock() dan kunci dilepaskan dengan memanggil kaedah lock.unlock(). Apa yang perlu diperhatikan apabila menggunakan ReentrantLock ialah logik untuk memperoleh dan melepaskan kunci mesti diletakkan dalam blok cuba-akhir untuk memastikan kunci dapat dilepaskan dengan betul.

3. Gunakan kelas ConcurrentHashMap

Di Java, ConcurrentHashMap ialah pelaksanaan jadual cincang selamat benang. ConcurrentHashMap menggunakan mekanisme kunci segmen untuk membahagikan keseluruhan jadual cincang kepada berbilang segmen. Elemen dalam segmen berbeza boleh diakses oleh berbilang urutan pada masa yang sama. Berikut ialah kod sampel, menggunakan ConcurrentHashMap untuk keselamatan benang:

import java.util.concurrent.ConcurrentHashMap;
public class Counter {
    private ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
    public void increment(String key) {
        map.put(key, map.getOrDefault(key, 0) + 1);
    }
    public int getCount(String key) {
        return map.getOrDefault(key, 0);
    }
}

Dalam kod di atas, ConcurrentHashMap digunakan untuk menyimpan nilai pembilang, dan kaedah map.put() dan map.getOrDefault() digunakan untuk mengemas kini dan dapatkan nilai kaunter. Memandangkan ConcurrentHashMap selamat untuk benang, pelaksanaan ini memastikan bahawa nilai pembilang adalah betul apabila berbilang benang mengaksesnya pada masa yang sama.

4. Gunakan kelas Atom

Di Jawa, kelas Atom menyediakan satu siri operasi atom untuk memastikan operasi dilakukan secara atom. Kelas atom termasuk AtomicBoolean, AtomicInteger, AtomicLong, dsb. Di bawah ialah contoh kod yang menunjukkan penggunaan AtomicInteger untuk mencapai keselamatan benang:

import java.util.concurrent.atomic.AtomicInteger;
public class Counter {
    private AtomicInteger count = new AtomicInteger();
    public void increment() {
        count.incrementAndGet();
    }
    public int getCount() {
        return count.get();
    }
}

Dalam kod di atas, AtomicInteger digunakan untuk menyimpan nilai pembilang, dan kaedah count.incrementAndGet() digunakan untuk mengemas kini nilai kaunter. Memandangkan AtomicInteger selamat untuk benang, pelaksanaan ini memastikan bahawa nilai pembilang adalah betul apabila berbilang benang mengaksesnya secara serentak.

5 Gunakan kelas ThreadLocal

Kelas ThreadLocal membenarkan setiap utas mempunyai salinan pembolehubahnya sendiri Apabila beberapa utas dijalankan serentak, setiap utas boleh mengendalikan salinan pembolehubahnya sendiri, dengan itu mengelakkan masalah keselamatan utas. Berikut ialah contoh kod untuk melaksanakan keselamatan benang menggunakan ThreadLocal:

public class Counter {
    private ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);
    public void increment() {
        threadLocal.set(threadLocal.get() + 1);
    }
    public int getCount() {
        return threadLocal.get();
    }
}

Dalam kod di atas, kelas ThreadLocal digunakan untuk menyimpan nilai pembilang, dan kaedah threadLocal.set() dan threadLocal.get() digunakan untuk mengemas kini dan mendapatkan nilai kaunter. Tetapkan setiap utas untuk mempunyai salinan bebas pembolehubah untuk memastikan bahawa nilai pembilang adalah tepat apabila berbilang utas mengaksesnya pada masa yang sama.

Untuk meringkaskan

Artikel ini memperkenalkan beberapa kaedah untuk mencapai keselamatan thread di Java, termasuk kata kunci disegerakkan, kelas ReentrantLock, kelas ConcurrentHashMap, kelas Atomic, kelas ThreadLocal, dsb. Mengikut keperluan sebenar, anda perlu memilih kaedah yang sesuai Setiap kaedah mempunyai ciri dan senario yang boleh digunakan. Untuk mengoptimumkan prestasi sistem dan keselarasan, keselamatan benang boleh dicapai dengan menggabungkan pelbagai kaedah.

Atas ialah kandungan terperinci Pengenalan kepada idea pelaksanaan keselamatan benang dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!