Pengaturcaraan Serentak Java: Analisis Contoh Penggunaan Integer Atom Integer Atom JUC Toolkit

Kelas AtomicInteger menyimpan nilai int di bahagian bawah dan menyediakan kaedah untuk melaksanakan operasi atom pada nilai int. AtomicInteger telah diperkenalkan bermula dengan Java 1.5 sebagai sebahagian daripada pakej java.util.concurrent.atomic.

1. Penggunaan asas AtomicInteger

Melalui kaedah pembina AtomicInteger di bawah, anda boleh mencipta objek AtomicInteger, nilai awal yang lalai kepada 0. AtomicInteger Menyediakan kaedah dapatkan dan tetapkan untuk mendapatkan nilai integer int yang mendasari dan tetapkan nilai integer int

//初始值为0的atomicInteger对象
AtomicInteger atomicInteger = new AtomicInteger();  
//初始值为200的atomicInteger对象
AtomicInteger atomicInteger = new AtomicInteger(200);
int currentValue = atomicInteger.get();         //100
atomicInteger.set(2453);                        //现在的值是 2453

Tetapi kaedah di atas bukanlah kandungan teras AtomicInteger, AtomicInteger Kandungan teras tercermin dalam keatomannya, yang akan kami perkenalkan di bawah.

2. Bilakah anda perlu menggunakan AtomicInteger

Kami biasanya menggunakannya dalam dua senario berikutAtomicInteger

Untuk mengendalikan kaunter dalam senario serentak berbilang benang , anda perlu memastikan bahawa kaunter Atomity operasi.

Bandingkan nilai Jika nilai yang diberikan adalah sama dengan nilai semasa, kemas kini nilai dan laksanakan algoritma tidak menyekat untuk operasi.

2.1. Senario pembilang atom

Gunakan AtomicInteger sebagai pembilang AtomicInteger menyediakan beberapa kaedah untuk melakukan operasi atom bagi penambahan dan penolakan.

Sebagai contoh, untuk mendapatkan nilai daripada peta, gunakan kaedah get(), iaitu operasi pertama selepas mendapat nilai, tambah n pada nilai, iaitu operasi tambah; akan dilakukan Operasi ketiga ialah meletakkan nilai ke dalam peta semula. Apa yang dipanggil atomicity of operations bermaksud bahawa dalam senario serentak berbilang benang, ketiga-tiga operasi di atas adalah atom, iaitu, tidak boleh dibahagikan. Tidak akan ada situasi di mana utas A mendapat nilai dan utas B juga mendapat nilai pada masa yang sama Kedua-dua utas melakukan operasi pada nilai pada masa yang sama dan memasukkannya semula satu demi satu Keadaan ini tidak akan berlaku AtomicInteger. AtomicIntegerOperasi adalah selamat untuk benang dan tidak boleh dibahagikan.

addAndGet()- Tambahkan nilai yang diberikan kepada nilai semasa dan kembalikan nilai baharu selepas penambahan, memastikan keatoman operasi.

getAndAdd() - Menambah nilai yang diberikan kepada nilai semasa dan mengembalikan nilai lama, memastikan atomicity operasi.

incrementAndGet() - Meningkatkan nilai semasa sebanyak 1 dan mengembalikan nilai baharu selepas meningkat. Ia bersamaan dengan operasi ++i dan menjamin keatoman operasi.

getAndIncrement() - Naikkan nilai semasa sebanyak 1 dan kembalikan nilai lama. Bersamaan dengan operasi ++i dan memastikan keatoman operasi.

decrementAndGet()- Tolak 1 daripada nilai semasa dan kembalikan nilai baharu selepas penolakan, yang bersamaan dengan operasi i-- dan menjamin keatoman operasi.

getAndDecrement() - Tolak 1 daripada nilai semasa dan kembalikan nilai lama. Ia bersamaan dengan operasi --i dan menjamin keatoman operasi.

Berikut ialah contoh kaedah operasi atom AtomicInteger

public class Main {
    public static void main(String[] args) {
        //初始值为100的atomic Integer
        AtomicInteger atomicInteger = new AtomicInteger(100);
        System.out.println(atomicInteger.addAndGet(2));         //加2并返回102
        System.out.println(atomicInteger);                      //102
        System.out.println(atomicInteger.getAndAdd(2));         //先获取102，再加2
        System.out.println(atomicInteger);                      //104
        System.out.println(atomicInteger.incrementAndGet());    //加1再获取105   
        System.out.println(atomicInteger);                      //105   
        System.out.println(atomicInteger.getAndIncrement());    //先获取105再加1
        System.out.println(atomicInteger);                      //106
        System.out.println(atomicInteger.decrementAndGet());    //减1再获取105
        System.out.println(atomicInteger);                      //105
        System.out.println(atomicInteger.getAndDecrement());    //先获取105，再减1
        System.out.println(atomicInteger);                      //104
    }
}

2.2. Perbandingan angka dan operasi pertukaran

Operasi compareAndSet membandingkan kandungan lokasi memori. dengan diberi Nilai dibandingkan dan hanya jika ia adalah sama, kandungan lokasi memori itu diubah suai kepada nilai baharu yang diberikan. Proses ini diselesaikan sebagai operasi atom tunggal.

kaedah compareAndSet: Jika nilai semasa == nilai dijangka, tetapkan nilai kepada nilai kemas kini yang diberikan.

boolean compareAndSet(int expect, int update)

expect ialah nilai yang dijangkakan

update ialah nilai yang dikemas kini

contoh AtomicInteger compareAndSet()

import java.util.concurrent.atomic.AtomicInteger;
public class Main {
    public static void main(String[] args) {
        //初始值为100的atomic Integer
        AtomicInteger atomicInteger = new AtomicInteger(100);
        //当前值100 = 预期值100，所以设置atomicInteger=110
        boolean isSuccess = atomicInteger.compareAndSet(100,110);  
        System.out.println(isSuccess);      //输出结果为true表示操作成功
        //当前值110 = 预期值100？不相等，所以atomicInteger仍然等于110
        isSuccess = atomicInteger.compareAndSet(100,120);  
        System.out.println(isSuccess);      //输出结果为false表示操作失败
    }
}

3 . Ringkasan

AtomicInteger boleh membantu kami mencapai keselamatan benang dan keatoman operasi berangka int dalam senario berbilang benang tanpa menggunakan kunci penyegerakan. Dan menggunakan AtomicInteger untuk melaksanakan operasi atom pada nilai int jauh lebih cekap daripada menggunakan kunci penyegerakan yang disegerakkan. Pakej

java.util.concurrent.atomic bukan sahaja memberikan kita AtomicInteger, tetapi juga menyediakan kelas operasi atom AtomicBoolean, kelas operasi atom Boolean integer panjang panjang AtomicLong, kelas operasi atom objek AtomicReference dan tatasusunan integer AtomicIntegerArray kelas operasi atom, kelas operasi atom tatasusunan integer panjang AtomicLongArray, kelas operasi atom tatasusunan objek AtomicReferenceArray.

Atas ialah kandungan terperinci Pengaturcaraan Serentak Java: Analisis Contoh Penggunaan Integer Atom Integer Atom JUC Toolkit. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!