Prinsip dan pelaksanaan di sebalik koleksi serentak Java

ConcurrencyKoleksiIkhtisar

"Principles and Implementation Behind Java Concurrent Collections" yang dilancarkan oleh editor PHP Yuzai meneroka dengan mendalam prinsip, kaedah pelaksanaan dan penggunaan kelas koleksi serentak Java. Melalui topik ini, pembaca akan mempunyai pemahaman yang menyeluruh tentang mekanisme di sebalik pelbagai koleksi serentak di Jawa, menyediakan rujukan penting untuk menyelesaikan isu keselamatan dan kecekapan apabila berbilang benang mengakses data secara serentak.

CopyOnWriteArrayList

CopyOnWriteArrayList ialah pelaksanaan ArrayList selamat benang yang menggunakan strategi copy-on-write untuk memastikan keselamatan thread. Dalam strategi salin atas tulis, apabila utas cuba mengubah suai CopyOnWriteArrayList, tika ArrayList baharu dicipta dan elemen dalam koleksi asal disalin ke tika baharu. Kemudian, pengubahsuaian dibuat pada contoh baharu, meninggalkan koleksi asal tidak berubah. Strategi ini memastikan bahawa pengubahsuaian kepada CopyOnWriteArrayList adalah atom dalam persekitaran berbilang benang dan tidak akan menyebabkan ketidakkonsistenan data.

Kod demo:

import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListExample {

public static void main(String[] args) {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("Item 1");
list.add("Item 2");
list.add("Item 3");

// 创建一个新的线程并尝试修改 list
Thread thread = new Thread(() -> {
list.add("Item 4");
});
thread.start();

// 主线程继续对 list 进行修改
list.add("Item 5");

// 打印最终的 list
System.out.println(list);
}
}

Hasil keluaran:

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {

public static void main(String[] args) {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("Item 1", 1);
map.put("Item 2", 2);
map.put("Item 3", 3);

// 创建一个新的线程并尝试修改 map
Thread thread = new Thread(() -> {
map.put("Item 4", 4);
});
thread.start();

// 主线程继续对 map 进行修改
map.put("Item 5", 5);

// 打印最终的 map
System.out.println(map);
}
}

Hasil keluaran:

import java.util.concurrent.ConcurrentLinkedQueue;

public class ConcurrentLinkedQueueExample {

public static void main(String[] args) {
ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
queue.add("Item 1");
queue.add("Item 2");
queue.add("Item 3");

// 创建一个新的线程并尝试修改 queue
Thread thread = new Thread(() -> {
queue.add("Item 4");
});
thread.start();

// 主线程继续对 queue 进行修改
queue.add("Item 5");

// 打印最终的 queue
System.out.println(queue);
}
}

Hasil keluaran:

[Item 1, Item 2, Item 3, Item 5, Item 4]

Dalam contoh ini, utas utama dan utas baharu mengubah suai baris gilir pada masa yang sama, tetapi kerana ConcurrentLinkedQueue menggunakan strategi operasi CAS, pengubahsuaian kedua-dua utas adalah atom dan tidak akan menyebabkan ketidakkonsistenan data.

Atas ialah kandungan terperinci Prinsip dan pelaksanaan di sebalik koleksi serentak Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!