जावा मानचित्र: multithreading juggler - जावा, multithreading, संग्रह, मानचित्र, concurrency

मुझे अगली समस्याओं का सामना करना पड़ा:

  1. मेरे पास कई असीमित पाठक और लेखक हैं।क्या जेडीके को कोई कार्यान्वयन मिला है जो मेरे मामले के लिए थ्रेड सुरक्षा प्रदान करता है? जैसा कि मैं समझता हूं ConcurrentHashMap स्थिति के लिए उपयुक्त नहीं है जब कई asynch लेखकों हैं।
  2. अगर मुझे एक दूसरे के बीच दो समवर्ती नक्शे सिंक्रनाइज़ करने की आवश्यकता है, तो क्या मैं इसे पूर्ण सिंक्रनाइज़ेशन के बिना प्राप्त कर सकता हूं? (मेरा मतलब है कि प्रत्येक विधि में synchonized कीवर्ड जोड़ने के बिना)

मैंने आपकी टिप्पणियां पढ़ीं और मेरे प्रश्न को सुधारने का फैसला किया।

स्थिति की कल्पना करो, आपको समवर्ती नक्शे करना होगा:

//Singleton
public class Container {
public ConcurrentHashMap<String, MyObj> map1 = new ConcurrentHashMap<String, MyObj>();
public ConcurrentHashMap<String, MyObj> map2 = new ConcurrentHashMap<String, MyObj>();

public void replaceForward(String key) {
Object value = map1.remove(key);
map2.put(key, value);
}

public void replaceBackward(String key) {
MyObj value = map2.remove(key);
map1.put(key, value);
}

//This operation should be as quick as possible!
public void replaceAllForward(int criteria) {
for (Map.Entry<String, MyObj> entry entry : map1.entrySet()) {
if (entry.getValue().criteria = criteria) {
replaceForward(entry.getKey());
}
}
}

//This operation should be as quick as possible!
public void replaceAllBackward(String key) {
//just the same but from map2 to map1
}

public void remove(String key) {
map1.remove(key);
}

public void add(String key, MyObj value) {
map2.put(key, value);
}

//This operation should be as quick as possible!
public Map<String, MyObj> getByCriteria(int criteria) {
ConcurrentHashMap<String, MyObj> resultMap = new ConcurrentHashMap<String, MyObj>();
for (Map.Entry<String, MyObj> entry entry : map1.entrySet()) {
if (entry.getValue().criteria = criteria) {
resultMap.put(entry.getKey(), entry.getValue);
}
}
return resultMap;
}
}

और आपके पास दो धागे हैं, दोनों नक्शे के साथ काम करते हैं।

Thread1: तत्वों को बदल देता है map1 सेवा मेरे map2 (मेरा मतलब है से हटा देता है map1 और रखता है map2)

Thread1: तत्वों को बदल देता है map2 सेवा मेरे map1

सवाल: क्या यह धागा सुरक्षित है?

उत्तर:

उत्तर № 1 के लिए 1

ConcurrentHashMap के साथ आपके उदाहरण में और यदि आप लिखते हैं:

V value = map1.remove(key);
if (value != null) map2.put(key, value);

आपके पास गारंटी है कि कोई भी आइटम "खो गया" नहीं होगा और मल्टीप्लर पाठकों / लेखकों की उपस्थिति में भी एक बार मैप 2 में कोई आइटम जोड़ा नहीं जाएगा।

हालांकि एक छोटा सा समय होगा जिसके दौरान कुंजी / मान map1 या map2 में नहीं होगा। यह आपके उपयोग के मामले में कोई समस्या हो सकती है या नहीं भी हो सकती है।

आपके में replaceAllForward आप एक मानचित्र पर फिर से चलते हैं और सामग्री को स्थानांतरित करते हैंदूसरा नक्शा यहां फिर से, यह कदम सुरक्षित रूप से होगा, लेकिन अंत में मूल मानचित्र में कुछ आइटम छोड़े जा सकते हैं यदि वे इस दौरान जोड़े गए हैं।


कैसे बनाना है getAllByCriteria और तेज?

यह आपके मानचित्र के आकार पर निर्भर करता है। यदि यह छोटा-साश है, तो आप शायद बेहतर नहीं कर सकते हैं। यदि यह बड़ा है, तो आप नौकरी समानांतर कर सकते हैं।

जावा 8 के साथ, आप शायद कुछ बेहतर प्रदर्शन कर सकते हैं जैसे:

public Map<String, MyObj> getByCriteria(int criteria) {
return map1.entrySet()
.parallelStream() //this is your speedup
.filter(e -> e.getValue().criteria = criteria)
.collect(toConcurrentMap(Entry::getKey, Entry::getValue));
}

जावा 8 से पहले, आप समानांतर अलगो लिख सकते हैं और देख सकते हैं कि यह प्रदर्शन में सुधार करता है या नहीं।


संबंधित सवाल
सबसे लोकप्रिय