Quelle est la différence entre hashmap et concurrenthashmap

Différence : HashMap n'est pas sécurisé pour les threads. Lorsque des opérations multithread se produisent, des risques de sécurité peuvent survenir ; ConcurrentHashMap est sécurisé pour les threads. HashMap ne prend pas en charge les opérations simultanées et n'a pas de méthode de synchronisation ; ConcurrentHashMap prend en charge les opérations simultanées.

L'environnement d'exploitation de ce tutoriel : système Windows 7, version Java 10, ordinateur DELL G3.

La différence entre hashmap et concurrenthashmap

• HashMap n'est pas sécurisé pour les threads. Lorsque des opérations multithread se produisent, des risques de sécurité surviennent tandis que ConcurrentHashMap. Est-il thread-safe.

• HashMap ne prend pas en charge les opérations simultanées et n'a pas de méthode de synchronisation. ConcurrentHashMap prend en charge les opérations simultanées en héritant de ReentrantLock (verrou réentrant JDK1.7)/CAS et synchronisé (verrou intégré JDK1.8). ) Lors du verrouillage (verrouillage de segment), chaque opération qui doit être verrouillée verrouille un segment de cette manière, tant que chaque segment est thread-safe, la sécurité globale des threads est obtenue.

ConcurrentHashMap utilise la technologie de segmentation de verrouillage pour segmenter l'ensemble du compartiment de hachage, c'est-à-dire que ce grand tableau est divisé en plusieurs petits segments, et chaque petit segment Il y a des verrous sur les segments de segment, donc lors de l'insertion d'éléments, vous devez d'abord trouver quel segment doit être inséré, puis insérer sur ce segment, et vous devez également obtenir le verrouillage du segment.

ConcurrentHashMap rend la granularité du verrouillage plus raffinée et les performances de concurrence meilleures.

(Tutoriel recommandé : Tutoriel d'introduction à Java)

HashMap

HashMap n'est pas sécurisé pour les threads. La méthode put ne l'est pas. gérer les verrous.Lorsque plusieurs threads sont libérés, il y aura des problèmes de sécurité des threads.Voici un exemple simple pour démontrer que trois threads sont créés et démarrés, 100 valeurs sont stockées dans la carte via une boucle for. , puis affiche la taille de la carte. Normalement, la taille de la carte devrait être de 100, mais 176 est affichée ici.

class Demo implements Runnable{
    static Map<String,String> map = new HashMap<>();

    @Override
    public void run() {
        for (int i = 0; i < 100; i ++) {
            map.put(i + "","value");
        }
    }

    public static void main(String[] args) {

        new Thread(new Demo()).start();
        new Thread(new Demo()).start();
        new Thread(new Demo()).start();
        // 获取当前线程
        Thread currentThread = Thread.currentThread();
        // 当前线程睡眠2秒，让上面的三个线程先执行
        try {
            currentThread.sleep(2000);
        } catch (Exception e) {
            e.getMessage();
        }
        // 上面的线程执行完毕后输出map的大小
        System.out.println(map.size());
    }
}

HashTable

HashTable utilise un verrou, et le verrou est ajouté directement à la méthode put Le fil est définitivement sûr. . , nous testons ici la sécurité des threads tout en examinant le temps d'exécution. Ici, nous mettons 10 000 données à tester. D'après les résultats, nous pouvons voir que la taille de la carte est effectivement de 10 000 et que le temps a pris environ 16 ms.

class Demo implements Runnable{
    static Map<String,String> map = new Hashtable<>();

    @Override
    public void run() {
        long startTime = System.currentTimeMillis(); //获取开始时间
        for (int i = 0; i < 10000; i ++) {
            map.put(i + "","value");
        }
        long endTime = System.currentTimeMillis(); //获取结束时间
        System.out.println((endTime - startTime) + "ms");
    }

    public static void main(String[] args) {

        new Thread(new Demo()).start();
        new Thread(new Demo()).start();
        new Thread(new Demo()).start();
        // 获取当前线程
        Thread currentThread = Thread.currentThread();
        // 当前线程睡眠2秒，让上面的三个线程先执行
        try {
            currentThread.sleep(2000);
        } catch (Exception e) {
            e.getMessage();
        }
        // 上面的线程执行完毕后输出map的大小
        System.out.println(map.size());
    }
}

ConcurrentHashMap

ConcurrentHashMap utilise le verrouillage de segmentation, ce qui n'est pas sûr. Verrouillez simplement quelle partie , si vous ne pouvez pas le laisser déverrouillé, ou si vous ne pouvez pas tout verrouiller, alors je le verrouillerai ! Vérifiez si ce verrouillage de bloc est plus rapide ou plus lent que le verrouillage de méthode.

class Demo implements Runnable{
    static Map<String,String> map = new ConcurrentHashMap<>();

    @Override
    public void run() {
        long startTime = System.currentTimeMillis(); //获取开始时间
        for (int i = 0; i < 10000; i ++) {
            map.put(i + "","value");
        }
        long endTime = System.currentTimeMillis(); //获取结束时间
        System.out.println((endTime - startTime) + "ms");
    }

    public static void main(String[] args) {

        new Thread(new Demo()).start();
        new Thread(new Demo()).start();
        new Thread(new Demo()).start();
        // 获取当前线程
        Thread currentThread = Thread.currentThread();
        // 当前线程睡眠2秒，让上面的三个线程先执行
        try {
            currentThread.sleep(2000);
        } catch (Exception e) {
            e.getMessage();
        }
        // 上面的线程执行完毕后输出map的大小
        System.out.println(map.size());
    }
}

Comme vous pouvez le voir d'après les résultats, il s'est amélioré des 20 ms et 22 ms précédents aux 17 ms et 18 ms actuels

Pour plus de connaissances liées à la programmation informatique, veuillez visiter : Vidéo de programmation ! !

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!