इसके अलावा जो सुझाव दिया गया है, मैं उससे संबंधित स्रोत कोड पोस्ट करना चाहूंगा SynchronizedMap ।
एक Mapधागा सुरक्षित बनाने के लिए , हम उपयोग कर सकते हैंCollections.synchronizedMap कथन का और पैरामीटर के रूप में मानचित्र उदाहरण इनपुट ।
के कार्यान्वयन synchronizedMapमें Collectionsनीचे की तरह है
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
return new SynchronizedMap<>(m);
}
जैसा कि आप देख सकते हैं, इनपुट Mapऑब्जेक्ट ऑब्जेक्ट द्वारा लपेटा गया है SynchronizedMap।
के कार्यान्वयन में खुदाई करते हैं SynchronizedMap,
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();}
}
private transient Set<K> keySet;
private transient Set<Map.Entry<K,V>> entrySet;
private transient Collection<V> values;
public Set<K> keySet() {
synchronized (mutex) {
if (keySet==null)
keySet = new SynchronizedSet<>(m.keySet(), mutex);
return keySet;
}
}
public Set<Map.Entry<K,V>> entrySet() {
synchronized (mutex) {
if (entrySet==null)
entrySet = new SynchronizedSet<>(m.entrySet(), mutex);
return entrySet;
}
}
public Collection<V> values() {
synchronized (mutex) {
if (values==null)
values = new SynchronizedCollection<>(m.values(), mutex);
return values;
}
}
public boolean equals(Object o) {
if (this == o)
return true;
synchronized (mutex) {return m.equals(o);}
}
public int hashCode() {
synchronized (mutex) {return m.hashCode();}
}
public String toString() {
synchronized (mutex) {return m.toString();}
}
// Override default methods in Map
@Override
public V getOrDefault(Object k, V defaultValue) {
synchronized (mutex) {return m.getOrDefault(k, defaultValue);}
}
@Override
public void forEach(BiConsumer<? super K, ? super V> action) {
synchronized (mutex) {m.forEach(action);}
}
@Override
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
synchronized (mutex) {m.replaceAll(function);}
}
@Override
public V putIfAbsent(K key, V value) {
synchronized (mutex) {return m.putIfAbsent(key, value);}
}
@Override
public boolean remove(Object key, Object value) {
synchronized (mutex) {return m.remove(key, value);}
}
@Override
public boolean replace(K key, V oldValue, V newValue) {
synchronized (mutex) {return m.replace(key, oldValue, newValue);}
}
@Override
public V replace(K key, V value) {
synchronized (mutex) {return m.replace(key, value);}
}
@Override
public V computeIfAbsent(K key,
Function<? super K, ? extends V> mappingFunction) {
synchronized (mutex) {return m.computeIfAbsent(key, mappingFunction);}
}
@Override
public V computeIfPresent(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
synchronized (mutex) {return m.computeIfPresent(key, remappingFunction);}
}
@Override
public V compute(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
synchronized (mutex) {return m.compute(key, remappingFunction);}
}
@Override
public V merge(K key, V value,
BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
synchronized (mutex) {return m.merge(key, value, remappingFunction);}
}
private void writeObject(ObjectOutputStream s) throws IOException {
synchronized (mutex) {s.defaultWriteObject();}
}
}
SynchronizedMapइनपुट Mapऑब्जेक्ट की प्राथमिक विधि में एकल लॉक जोड़ने के रूप में संक्षेप में क्या किया जा सकता है । एक ही समय में कई थ्रेड्स द्वारा लॉक द्वारा संरक्षित सभी विधि तक पहुँचा नहीं जा सकता है। इसका मतलब है कि सामान्य ऑपरेशन जैसे putऔर getसभी डेटा के लिए एक ही समय में एक ही थ्रेड द्वारा निष्पादित किया जा सकता हैMap ऑब्जेक्ट ।
यह बनाता है Map ऑब्जेक्ट थ्रेड को सुरक्षित लेकिन प्रदर्शन कुछ परिदृश्यों में एक मुद्दा बन सकता है।
ConcurrentMapकहीं अधिक कार्यान्वयन में जटिल है, हम उल्लेख कर सकते हैं एक बेहतर HashMap बिल्डिंग जानकारी के लिए। संक्षेप में, यह थ्रेड को सुरक्षित और प्रदर्शन दोनों को ध्यान में रखते हुए लागू किया गया है।