Les principes et la mise en œuvre derrière les collections simultanées Java

ConcurrencyCollectionAperçu

Les « Principes et implémentation derrière les collections simultanées Java » lancés par l'éditeur PHP Yuzai explorent en profondeur les principes, les méthodes d'implémentation et l'utilisation des classes de collections simultanées Java. Grâce à ce sujet, les lecteurs auront une compréhension complète des mécanismes derrière diverses collections simultanées en Java, fournissant une référence importante pour résoudre les problèmes de sécurité et d'efficacité lorsque plusieurs threads accèdent simultanément aux données.

CopyOnWriteArrayList

CopyOnWriteArrayList est une implémentation ArrayList thread-safe qui utilise la stratégie de copie sur écriture pour garantir la sécurité des threads. Dans la stratégie de copie sur écriture, lorsqu'un thread tente de modifier CopyOnWriteArrayList, une nouvelle instance ArrayList est créée et les éléments de la collection d'origine sont copiés dans la nouvelle instance. Ensuite, des modifications sont apportées à la nouvelle instance, laissant la collection d'origine inchangée. Cette stratégie garantit que les modifications apportées à CopyOnWriteArrayList sont atomiques dans un environnement multithread et n'entraîneront pas d'incohérence des données.

Code démo :

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

Résultat de sortie :

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

Résultat de sortie :

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

Résultat de sortie :

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

Dans cet exemple, le thread principal et le nouveau thread modifient la file d'attente en même temps, mais comme ConcurrentLinkedQueue utilise la stratégie d'opération CAS, les modifications des deux threads sont atomiques et ne provoqueront pas d'incohérence des données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!