Java中Map實現線程安全的方法有哪些

這篇文章主要介紹了Java中Map實現線程安全的方法有哪些的相關知識，內容詳細易懂，操作簡單快捷，具有一定借鑒價值，相信大家閱讀完這篇Java中Map實現線程安全的方法有哪些文章都會有所收獲，下面我們一起來看看吧。

方式1.  使用Hashtable

Map<String,Object> hashtable=new Hashtable<String,Object>();

這是所有人最先想到的，那為什么它是線程安全的？那就看看它的源碼,我們可以看出我們常用的put,get，containsKey等方法都是同步的，所以它是線程安全的

public synchronized boolean containsKey(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return true;
            }
        }
        return false;
    }

 public synchronized V get(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V)e.value;
            }
        }
        return null;
    }
     public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the hashtable.
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        for(; entry != null ; entry = entry.next) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }

        addEntry(hash, key, value, index);
        return null;
    }

其實現原理是在增刪改查的方法上使用了synchronized鎖機制，在多線程環境下，無論是讀數據，還是修改數據，在同一時刻只能有一個線程在執行synchronize方法，因為是對整個表進行鎖定。所以線程越多，對該map的競爭越激烈，效率越低，不推薦使用。

方式2.  使用Collections.synchronizedMap(new Hashtable())

其實現原理是使用工具類里面的靜態方法，把傳入進來的Hashtable包裝成同步的，即在增刪改查的方法上增加了synchronized所機制，其實現方式與Hashtable差不多，效率也差不多，不推薦使用。

Map map = Collections.synchronizedMap(new Hashtable());

以下是JDK源碼

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
        return new SynchronizedMap<>(m);
}
private static class SynchronizedMap<K,V>
        implements Map<K,V>, Serializable {
        private static final long serialVersionUID = 1978198479659022715L;
 
        private final Map<K,V> m;     // Backing Map
        final Object      mutex;        // Object on which to synchronize
 
        SynchronizedMap(Map<K,V> m) {
            this.m = Objects.requireNonNull(m);
            mutex = this;
        }
 
        SynchronizedMap(Map<K,V> m, Object mutex) {
            this.m = m;
            this.mutex = mutex;
        }
 
        public int size() {
            synchronized (mutex) {return m.size();}
        }
        public boolean isEmpty() {
            synchronized (mutex) {return m.isEmpty();}
        }
        public boolean containsKey(Object key) {
            synchronized (mutex) {return m.containsKey(key);}
        }
        public boolean containsValue(Object value) {
            synchronized (mutex) {return m.containsValue(value);}
        }
        public V get(Object key) {
            synchronized (mutex) {return m.get(key);}
        }
 
        public V put(K key, V value) {
            synchronized (mutex) {return m.put(key, value);}
        }
        public V remove(Object key) {
            synchronized (mutex) {return m.remove(key);}
        }
        public void putAll(Map<? extends K, ? extends V> map) {
            synchronized (mutex) {m.putAll(map);}
        }
        public void clear() {
            synchronized (mutex) {m.clear();}
        }
        ......
    }

方式3.  使用ConcurrentHashMap

其實現原理是Hashtable是對整個表進行加鎖，而ConcurrentHashMap是把表進行分段，初始情況下分成16段，每一段都有一把鎖，當多個線程訪問不同的段時，因為獲取到的鎖是不同的，所以可以并行的訪問。效率比Hashtable高多了，推薦使用。

關于“Java中Map實現線程安全的方法有哪些”這篇文章的內容就介紹到這里，感謝各位的閱讀！相信大家對“Java中Map實現線程安全的方法有哪些”知識都有一定的了解，大家如果還想學習更多知識，歡迎關注億速云行業資訊頻道。