कॉन्करन्सी, ब्लॉकिंग क्यू (जावा 7) - १

"हाय, अमिगो!"

"हाय, किम!"

"आज मी तुम्हाला एकरूपतेबद्दल सांगणार आहे."

" Concurrency ही जावा क्लास लायब्ररी आहे ज्यामध्ये अनेक थ्रेड्समधून काम करण्यासाठी ऑप्टिमाइझ केलेले विशेष वर्ग समाविष्ट आहेत. हा एक अतिशय मनोरंजक आणि विस्तृत विषय आहे. परंतु आज आपण फक्त एक परिचय घेणार आहोत. पॅकेजचे नाव आहे java.util. समवर्ती पॅकेज. मी तुम्हाला काही मनोरंजक वर्गांबद्दल सांगेन."

" अणु प्रकार. "

"तुम्हाला आधीच माहित आहे की अगदी काउंट++ हे थ्रेड-सेफ ऑपरेशन नाही. जेव्हा व्हेरिएबल 1 ने वाढवले ​​जाते, तेव्हा प्रत्यक्षात तीन ऑपरेशन्स होतात. परिणामी, व्हेरिएबल बदलल्यावर संघर्ष होऊ शकतो."

"हो, एलीने मला फार पूर्वी सांगितले नाही:"

धागा १ धागा २ परिणाम
register1 = count;
register1++;
count = register1;
register2 = count;
register2++;
count = register2;
register1 = count;
register2 = count;
register2++;
count = register2;
register1++;
count = register1;

"अगदी. मग Java ने ही ऑपरेशन्स एक म्हणून करण्यासाठी डेटा प्रकार जोडले, म्हणजे अणुरीत्या (अणू अविभाज्य आहे)."

"उदाहरणार्थ, Java मध्ये AtomicInteger, AtomicBoolean, AtomicDouble इ. आहे."

"समजा आपल्याला एक «काउंटर» वर्ग बनवायचा आहे:"

उदाहरण
class Counter
{
 private int c = 0;

 public void increment()
 {
  c++;
 }

 public void decrement()
 {
  c--;
 }

 public int value()
 {
  return c;
 }
}

"तुम्ही या वर्गातील वस्तू थ्रेड-सेफ कसे बनवाल?"

"ठीक आहे, मी सर्व पद्धती समक्रमित करेन आणि ते पूर्ण करेन:"

उदाहरण
class synchronized Counter
{
 private int c = 0;

 public synchronized void increment()
 {
  c++;
 }

 public synchronized void decrement()
 {
  c--;
 }

 public synchronized int value()
 {
  return c;
 }
}

"चांगले काम. पण, आम्ही अणु प्रकार वापरले तर ते कसे दिसेल:"

उदाहरण
class AtomicCounter
{
 private AtomicInteger c = new AtomicInteger(0);

 public void increment()
 {
  c.incrementAndGet();
 }

 public void decrement()
 {
  c.decrementAndGet();
 }

 public int value()
 {
  return c.get();
 }
}

"तुमचा वर्ग आणि माझा वर्ग दोघेही सारखेच काम करतात, पण AtomicInteger असलेला वर्ग जलद काम करतो."

"बरं, थोडा फरक आहे का?"

"होय. माझ्या अनुभवाच्या आधारावर, मी नेहमी सिंक्रोनाइझसह अग्रगण्य करण्याची शिफारस करतो. जेव्हा सर्व ऍप्लिकेशन कोड लिहीले जातील आणि ऑप्टिमायझेशन प्रक्रिया सुरू झाली असेल तेव्हा तुम्ही अणू प्रकार वापरण्यासाठी कोड पुन्हा लिहायला सुरुवात केली पाहिजे. परंतु कोणत्याही परिस्थितीत, मला तुम्ही हवे होते. असे प्रकार अस्तित्त्वात आहेत हे जाणून घेण्यासाठी. जरी तुम्ही त्यांचा सक्रियपणे वापर करत नसला तरीही, ते वापरल्या जाणार्‍या कोडमध्ये जाण्याची शक्यता नेहमीच असते."

"मला मान्य आहे. अर्थ आहे."

"तसे, तुमच्या लक्षात आले का की अणूचे प्रकार अपरिवर्तनीय नाहीत? मानक पूर्णांक वर्गाच्या विरूद्ध , AtomicInteger मध्ये त्याची अंतर्गत स्थिती बदलण्याच्या पद्धती आहेत."

"समजले. जसे स्ट्रिंग आणि स्ट्रिंगबफर ."

"हो, असंच काहीतरी."

" थ्रेड-सेफ संग्रह. "

"अशा कलेक्शनचे उदाहरण म्हणून, मी ConcurrentHashMap सादर करू शकतो. तुम्ही HashMap थ्रेड-सेफ कसे बनवाल?"

"त्याच्या सर्व पद्धती समक्रमित करा?"

"नक्की, पण आता कल्पना करा की तुमच्याकडे असा एक सिंक्रोनाइज्ड हॅशमॅप आहे, आणि डझनभर थ्रेड्स त्यात प्रवेश करत आहेत. आणि सेकंदाला शंभर वेळा नवीन एंट्री नकाशावर जोडली जाते आणि प्रक्रियेत संपूर्ण ऑब्जेक्ट वाचन आणि लेखनासाठी लॉक केले जाते."

"बरं, हा मानक दृष्टिकोन आहे. तुम्ही काय करू शकता?"

"जावाचे निर्माते काही छान गोष्टी घेऊन आले आहेत."

"प्रथम, ते एकाच ब्लॉकमध्ये ConcurrentHashMap मध्ये डेटा संग्रहित करतात, परंतु 'बकेट्स' नावाच्या भागांमध्ये विभागतात. आणि जेव्हा कोणी ConcurrentHashMap मध्ये डेटा बदलतो, तेव्हा आम्ही संपूर्ण ऑब्जेक्टच्या ऐवजी फक्त बकेटमध्ये प्रवेश करतो. शब्द, अनेक धागे एकाच वेळी ऑब्जेक्ट बदलू शकतात."

"दुसरे, तुम्हाला आठवते का की तुम्ही सूची/नकाशामधील घटकांवर पुनरावृत्ती करू शकत नाही आणि त्याच वेळी सूची बदलू शकत नाही? अशा कोडला अपवाद असेल:"

लूपमधील संकलनाच्या घटकांवर पुनरावृत्ती करू नका आणि एकाच वेळी ते बदलू नका
HashMap<String, Integer> map = new HashMap<String, Integer>();

for (String key: map.keySet())
{
 if (map.get(key) == 0)
  map.remove(key);
}

"पण ConcurrentHashMap मध्ये, तुम्ही हे करू शकता:"

लूपमध्ये संग्रहातील घटकांवर पुनरावृत्ती करू नका आणि एकाच वेळी ते बदलू नका"
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();

for (String key: map.keySet())
{
 if (map.get(key) == 0)
  map.remove(key);
}

"समवर्ती पॅकेजचे बरेच फायदे आहेत. ते वापरण्यासाठी आम्हाला हे वर्ग चांगले समजून घेणे आवश्यक आहे."

"मी पाहतो. धन्यवाद, किम. हे खरोखरच मनोरंजक वर्ग आहेत. मला आशा आहे की एखाद्या दिवशी मी त्यांना एखाद्या गुणी व्यक्तीप्रमाणे पारंगत करेन."