Comment implémenter des structures de données sans verrouillage dans la programmation simultanée Java ?

Structures de données sans verrouillage dans la programmation simultanée Java

Dans la programmation simultanée, les structures de données sans verrouillage sont cruciales, permettant à plusieurs threads d'accéder et de modifier simultanément les mêmes données sans acquérir de verrou. Cela améliore considérablement les performances et le débit des applications. Cet article présentera les structures de données sans verrouillage couramment utilisées et leur implémentation en Java.

Opération CAS

Compare-and-Swap (CAS) est au cœur des structures de données sans verrouillage. Il s'agit d'une opération atomique qui met à jour une variable en comparant la valeur actuelle avec la valeur attendue. Si la valeur de la variable est égale à la valeur attendue, la mise à jour réussit ; sinon, la mise à jour échoue.

File d'attente sans verrouillage

ConcurrentLinkedQueue est une file d'attente sans verrouillage, qui est implémentée à l'aide d'une structure basée sur une liste chaînée. Il fournit des opérations d'insertion et de suppression efficaces sans conflit de verrouillage.

import java.util.concurrent.ConcurrentLinkedQueue;

public class ConcurrentQueueExample {
    public static void main(String[] args) {
        ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
        
        // 添加元素
        queue.add(1);
        queue.add(2);
        queue.add(3);
        
        // 遍历队列
        for (Integer num : queue) {
            System.out.println(num);
        }
    }
}

Pile sans verrouillage

ConcurrentLinkedDeque est une pile sans verrouillage qui peut également être utilisée comme file d'attente.

import java.util.concurrent.ConcurrentLinkedDeque;

public class ConcurrentStackExample {
    public static void main(String[] args) {
        ConcurrentLinkedDeque<Integer> stack = new ConcurrentLinkedDeque<>();
        
        // 入栈
        stack.push(1);
        stack.push(2);
        stack.push(3);
        
        // 出栈
        while (!stack.isEmpty()) {
            System.out.println(stack.pop());
        }
    }
}

Table de hachage sans verrouillage

ConcurrentHashMap est une table de hachage sans verrouillage qui fournit un accès simultané efficace.

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        
        // 添加键值对
        map.put("name", "John");
        map.put("age", 30);
        
        // 获取值
        System.out.println(map.get("name"));

        // 遍历键值对
        for (String key : map.keySet()) {
            System.out.println(key + ": " + map.get(key));
        }
    }
}

Cas pratiques

Les structures de données sans verrouillage sont largement utilisées dans les applications à haute concurrence, telles que :

• Serveurs Web : utilisés pour stocker les sessions et les files d'attente de requêtes.
• Système de stockage : Utilisé pour fournir des mises à jour atomiques et un accès simultané aux données.
• Système de communication : Pour mettre en mémoire tampon les messages et traiter les demandes.

En utilisant des structures de données sans verrouillage, les développeurs peuvent améliorer les performances des applications, réduire les conflits de verrouillage et augmenter l'évolutivité.

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!