Comment implémenter un verrouillage à double vérification dans les fonctions Java pour assurer la sécurité des threads ?

Le verrouillage à double vérification est un modèle de conception qui garantit la sécurité des threads grâce à une double vérification. Il peut être implémenté dans les fonctions Java comme suit : définissez une variable volatile statique pour stocker l'instance, si l'instance est vide, vérifiez-la à nouveau dans la synchronisation ; block, comme si vide, une instance est créée ; l'instance est renvoyée. Cas pratique : dans les scénarios de ressources partagées (tels que les classes de cache), l'utilisation du verrouillage par double vérification peut garantir que tous les threads utilisent la même instance partagée, évitant ainsi la concurrence des données et garantissant l'intégrité des données.

Verrouillage à double vérification dans les fonctions Java : un exemple pratique de sécurité des threads

Le verrouillage à double vérification est un modèle de conception qui utilise une double vérification pour garantir qu'une instance n'est créée qu'une seule fois, réalisant ainsi plusieurs filetage Fil sûr. Voici comment implémenter le verrouillage par double vérification dans une fonction Java :

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
        // ...省略构造函数逻辑
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

Cas pratique : ressources partagées par les threads

Considérons un scénario dans lequel les threads partagent des ressources, comme une classe de cache, où plusieurs threads peuvent accéder simultanément aux données mises en cache. temps. Pour éviter les conditions de concurrence des données, nous devons nous assurer que l'objet cache n'est créé qu'une seule fois et que tous les threads peuvent y accéder en toute sécurité :

public class Cache {
    private static volatile Cache instance;

    public static Cache getInstance() {
        if (instance == null) {
            synchronized (Cache.class) {
                if (instance == null) {
                    instance = new Cache();
                }
            }
        }
        return instance;
    }

    // 此处省略缓存逻辑
}

// 使用缓存
List<String> sharedData = new ArrayList<>();
sharedData.add("Item 1");
sharedData.add("Item 2");

for (int i = 0; i < 10; i++) {
    new Thread(() -> {
        Cache cache = Cache.getInstance();
        // 使用共享数据，例如将它添加到缓存中
        cache.put("Key" + i, sharedData);
        cache.get("Key" + i);
    }).start();
}

Dans l'exemple ci-dessus, la classe Cache utilise un verrouillage à double vérification pour garantir que tous les threads utilisent le même instance partagée. Cela évite la création de plusieurs instances de cache, garantissant ainsi la sécurité des threads et l'intégrité 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!