perkenalan
Java menyediakan paket java.util.concurrent.atomic sejak JDK1.5, yang memfasilitasi programmer untuk melakukan operasi atom tanpa kunci di lingkungan multi-threaded. Lapisan yang mendasari variabel atom menggunakan instruksi atom yang disediakan oleh prosesor, tetapi arsitektur CPU yang berbeda dapat memberikan instruksi atom yang berbeda, dan mungkin juga memerlukan beberapa bentuk kunci internal, sehingga metode ini tidak dapat dengan benar -benar memastikan bahwa utas tidak diblokir.
Pendahuluan Paket Atom
Ada 12 kelas dalam paket atom, dan empat metode pembaruan atom adalah: tipe dasar pembaruan atom, array pembaruan atom, referensi pembaruan atom dan bidang pembaruan atom. Kelas -kelas dalam paket atom pada dasarnya dibungkus kelas yang diimplementasikan menggunakan tidak aman.
Kelas Tipe Dasar Pembaruan Atom
Untuk memperbarui tipe dasar melalui metode atom, paket atom menyediakan tiga kelas berikut:
Atomicboolean: Atomik memperbarui tipe boolean.
AtomicInteger: Integer Pembaruan Atom.
Atomiclong: Pembaruan Atom Integer Panjang.
Metode umum atomicinteger adalah sebagai berikut:
int addandget (int delta): menambahkan nilai input ke nilai dalam instance (nilai di atomicinteger) dengan cara atom dan mengembalikan hasilnya
Boolean compareANDSet (int hare, int update): Jika nilai input sama dengan nilai yang diharapkan, atur nilai ke nilai input secara atom.
int getAndIncrement (): Menambahkan nilai saat ini ke 1 secara atom. Catatan: Nilai yang dikembalikan di sini adalah nilai sebelum autoINCREMENT.
void lazyset (int newValue): pada akhirnya akan diatur ke newValue. Setelah menggunakan lazyset untuk mengatur nilai, utas lain mungkin masih dapat membaca nilai lama int getAndset (int newValue): diatur ke nilai newValue dengan cara atom dan mengembalikan nilai lama.
Kode contoh AtomicInteger adalah sebagai berikut:
Impor java.util.concurrent.atomic.atomicinteger; kelas publik atomicintegertest {static atomicinteger ai = atomicinteger baru (1); public static main (string [] args) {System.out.println (ai.getandincrement ();Keluaran
12
Makanan penutup setelah makan malam
Paket atom menyediakan tiga jenis dasar pembaruan atom, tetapi tipe dasar Java termasuk char, float, dan double. Jadi pertanyaannya adalah, bagaimana memperbarui jenis atom dasar lainnya? Kelas -kelas dalam paket atom pada dasarnya diimplementasikan menggunakan tidak aman. Mari kita lihat kode sumber yang tidak aman. Kami menemukan bahwa tidak aman hanya menyediakan tiga metode CAS, CompareANDSWapObject, CompareandsWapint dan CompareandsWaplong. Kemudian lihat kode sumber Atomicboolean. Kami menemukan bahwa itu pertama -tama mengubah Boolean menjadi bilangan bulat, dan kemudian menggunakan CompareEndsWapint untuk CAS, sehingga pembaruan atom ganda juga dapat diimplementasikan menggunakan ide -ide serupa.
Kelas Array Pembaruan Atom
Paket atom menyediakan tiga kelas berikut:
AtomicIntegerarray: secara atom memperbarui elemen dalam array integer.
Atomiclongarray: Atomik pembaruan elemen dalam array panjang.
AtomicreferenceArray: Elemen pembaruan atom dalam array tipe referensi.
Kelas AtomicIntegerarray terutama menyediakan atomik untuk memperbarui bilangan bulat di array. Metode yang umum digunakan adalah sebagai berikut
int addandget (int i, int delta): menambahkan nilai input secara atom ke indeks elemen i di array.
Boolean CompareANDSet (int i, int hare, int update): Jika nilai saat ini sama dengan nilai yang diharapkan, elemen pada posisi array I secara atom diatur ke nilai pembaruan.
Kode contoh adalah sebagai berikut:
kelas publik atomicintegerarraytest {static int [] value = new int [] {1, 2}; statis atomicintegerarray ai = atomicintegerarray baru (nilai); public static void main (string [] args) {ai.getandset (0, 3); System.out.println (ai.get (0)); System.out.println (nilai [0]);}}Keluaran
31
Apa yang perlu Anda perhatikan di kelas AtomicIntegerArray adalah bahwa nilai array diteruskan melalui metode konstruktor, dan kemudian AtomicIntegerarray akan menyalin array saat ini salinan, jadi ketika AtomicIntegerarray memodifikasi elemen array internal, itu tidak akan mempengaruhi array yang diteruskan.
Jenis Referensi Pembaruan Atom
AtomicInteger, yang merupakan tipe dasar, hanya dapat memperbarui satu variabel. Jika Anda ingin memperbarui beberapa variabel secara atom, Anda perlu menggunakan atom ini untuk memperbarui kelas yang disediakan oleh jenis referensi. Paket atom menyediakan tiga kelas berikut:
ATOMICREFERENSI: ATOMIC memperbarui jenis referensi.
AtomicReferenceFieldUpdater: bidang pembaruan atom dalam jenis referensi.
AtomicmarkableReRerence: Atomic Memperbarui Jenis Referensi dengan Bit Marker. Anda dapat secara atomik memperbarui bit tag tipe boolean dan jenis referensi. Metode Konstruksi adalah AtomicmarkableReReference (V InitialRef, Boolean Initialmark)
Kode untuk menggunakan atomicreference adalah sebagai berikut:
public class AtomicReferenceTest {public static AtomicReference<user> atomicUserRef = new AtomicReference</user><user>();public static void main(String[] args) {User user = new User("conan", 15);atomicUserRef.set(user);User updateUser = new User("Shinichi", 17); atomicuserref.comppareandset (pengguna, updateUser); System.out.println (atomicuserref.get (). GetName ()); System.out.println (atomicuserref.get (getseold ());} Pengguna kelas statis {private string name; pribadi; String getName () {return name;} public int getold () {return old;}}}Keluaran
Shinichi17
Kelas bidang pembaruan atom
Jika kita hanya membutuhkan bidang tertentu di kelas tertentu, kita perlu menggunakan atom untuk memperbarui kelas lapangan. Paket atom menyediakan tiga kelas berikut:
AtomicIntegerFieldUpdater: Pembaruan untuk bidang yang secara atom memperbarui bilangan bulat.
Atomiclongfieldupdater: Pembaruan untuk pembaruan atom bidang bilangan bulat panjang.
AtomicstampedReference: Atomic memperbarui jenis referensi dengan nomor versi. Kelas ini mengaitkan nilai integer dengan referensi dan dapat digunakan untuk lebih banyak data atom dan nomor versi, yang dapat menyelesaikan masalah ABA yang mungkin timbul saat menggunakan CAS untuk pembaruan atom.
Kelas bidang pembaruan atom adalah kelas abstrak, dan setiap kali digunakan, mereka harus menggunakan metode statis Newupdater untuk membuat pembaruan. Pengubah volatil publik harus digunakan untuk bidang kelas pembaruan atom.
Langkah pertama adalah karena karena kelas bidang pembaruan atom adalah kelas abstrak, setiap kali Anda menggunakan metode statis atomicintegerfieldupdater.newupdater, Anda harus membuat pembaruan, dan Anda perlu mengatur kelas dan properti yang ingin Anda perbarui. Langkah kedua adalah memperbarui bidang (properti) kelas harus menggunakan pengubah volatil publik (private volatile int old)
Contoh Kode AtomicIntegerFieldUpdater adalah sebagai berikut:
public class AtomicIntegerFieldUpdaterTest {private static AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater.newUpdater(User.class, "old");public static void main(String[] args) {User conan = new User("conan", 10); System.out.println (a.getAndincrement (conan)); System.out.println (a.get (conan));} Public Static Class User {Private String Name; Public Volatile Int Lama; Pengguna Publik Getname, evand {this.name = name; this.old = Old;} public String getname (ev {this.name = name; this.old = old;} public string public getname () {{) {name; thisKeluaran
1011
Meringkaskan
Di atas adalah seluruh konten artikel ini tentang pengantar dan penggunaan paket atom multi-threaded java. Saya harap ini akan membantu semua orang. Teman yang tertarik dapat terus merujuk ke situs ini:
Pengantar Metode Menulis Model Konsumen Produksi Dalam Kondisi Berbeda di Java Multithreading
Java Multithreaded Programming Synchronizer Future dan Futuretask Parsing dan Contoh Kode
Penjelasan terperinci tentang kunci tampilan multi-threaded java dan kunci bawaan
Jika ada kekurangan, silakan tinggalkan pesan untuk menunjukkannya.