Apakah cara untuk melaksanakan keselamatan benang untuk Peta di Jawa?

Kaedah 1. Gunakan Hashtable

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

Ini adalah perkara pertama yang semua orang fikirkan, jadi mengapa ia selamat untuk benang? Kemudian lihat kod sumbernya. Kita dapat melihat bahawa kaedah yang biasa kita gunakan seperti put, get, containsKey, dsb. semuanya segerak, jadi ia selamat untuk thread

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

Prinsip pelaksanaannya ialah untuk menambah, memadam, mengubah suai dan menyemak Mekanisme kunci disegerakkan digunakan dalam kaedah Dalam persekitaran berbilang benang, sama ada membaca data atau mengubah suai data, hanya satu utas boleh melaksanakan kaedah penyegerakan pada masa yang sama kerana keseluruhan jadual. dikunci. Oleh itu, lebih banyak rangkaian, semakin sengit persaingan untuk peta dan semakin rendah kecekapan, jadi ia tidak disyorkan.

Kaedah 2. Gunakan Collections.synchronizedMap(new Hashtable())

Prinsip pelaksanaannya ialah menggunakan kaedah statik dalam kelas alat untuk membungkus Hashtable yang masuk menjadi satu yang disegerakkan, iaitu , dalam Mekanisme yang disegerakkan ditambah pada kaedah menambah, memadam, mengubah suai dan menyemak Pelaksanaannya adalah serupa dengan Hashtable, dan kecekapannya adalah serupa.

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

Berikut ialah kod sumber 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();}
        }
        ......
    }

Kaedah 3. Gunakan ConcurrentHashMap

Prinsip pelaksanaan ialah Hashtable mengunci keseluruhan jadual, manakala ConcurrentHashMap mengunci keseluruhan jadual. Pada mulanya, ia dibahagikan kepada 16 segmen. Setiap segmen mempunyai kunci Apabila berbilang benang mengakses segmen yang berbeza, ia boleh diakses secara selari. Kecekapan jauh lebih tinggi daripada Hashtable, jadi disyorkan untuk menggunakannya.

Atas ialah kandungan terperinci Apakah cara untuk melaksanakan keselamatan benang untuk Peta di Jawa?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!