যা প্রস্তাবিত হয়েছে তা ছাড়াও, আমি সম্পর্কিত উত্স কোড পোস্ট করতে চাই 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 নির্মাণের বিস্তারিত জানার জন্য। সংক্ষেপে, এটি থ্রেড নিরাপদ এবং কর্মক্ষমতা উভয় বিবেচনায় নিয়ে প্রয়োগ করা হয়েছে।