Locks, Semaphores, CountDownLatch Java In Hindi
जावा प्रोग्रामिंग लैंग्वेज में, java.util.concurrent थ्रेड टास्क पैकेज लाइब्रेरी जावा डेवलपर को मल्टीप्ल सिंक्रोनाइज़ेशन यूटिलिटी प्रोवाइड करता है. जिससे कि मल्टीप्ल थ्रेड्स टास्क के बीच कम्युनिकेशन और एक्सेस कंट्रोल को आसानी से मैनेज किया जा सके।
Java Thread Task Package Library contains three essential elements.
- लॉक्स फीचर्स कांसेप्ट
- सेमाफोर फीचर्स कांसेप्ट
- काउंटडाउनलैच फीचर्स कांसेप्ट
These Java Thread Tasks solve multiple individual multithreading problems.
Locks with java.util.concurrent class.
जावा थ्रेड टास्क में लॉक एक सिंक्रोनाइज़ेशन मैकेनिज्म टास्क है, जो यूजर को शेयर्ड रिसोर्स तक एक्सेस को कंट्रोल करने में हेल्प करता है।
लॉक कांसेप्ट फिक्स करता है कि जब एक यूजर डिफाइन थ्रेड टास्क किसी क्रिटिकल सेक्शन को एग्जीक्यूट कर रहा हो, तो दूसरा अन्य थ्रेड टास्क उसी लॉक का यूज़ करके उसी प्रोटेक्टेड सेक्शन में एंटर न कर सके।
The Java Lock provides an interface for you.
java.util.concurrent.locks
और एक सामान्य रूप से यूज़ होने वाला इम्प्लीमेंटेशन प्रोवाइड करता है.
ReentrantLock
Example of a Java thread task lock.
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Tester {
private int test_value = 0;
private final Lock lock = new ReentrantLock();
void increment() {
lock.lock();
try {
test_value++;
} finally {
lock.unlock();
}
}
int gettest_value() {
return test_value;
}
}
Explaining the Java thread task lock.
यहाँ इस एक्साम्प्ल में सबसे पहले, जावा यूजर एक लॉक को क्रिएट करते हैं.
private final Lock lock = new ReentrantLock();
जावा थ्रेड टास्क में शेयर्ड रिसोर्स को एक्सेस करने से पहले।
lock.lock();
थ्रेड टास्क अपने आप एक लॉक को ले लेता है।
थ्रेड टास्क में एक क्रिटिकल सेक्शन पूरा करने के बाद.
lock.unlock();
लॉक पूरी तरह से रिलीज़ हो जाता है।
इसमें finally ब्लॉक स्टेटमेंट ज़रूरी है, क्योंकि यह इस कंडीशन में फिक्स करता है कि थ्रेड एक्सेप्शन होने पर भी लॉक अपने आप रिलीज़ हो जाए।
synchronized vs Lock in java thread task
जावा थ्रेड टास्क में दोनों म्यूचुअल एक्सक्लूज़न फीचर्स प्रोवाइड कर सकते हैं, लेकिन Lock थ्रेड कांसेप्ट जावा डेवलपर को कुछ एक्स्ट्रा कंट्रोल प्रोवाइड करता है।
| # | Synchronized thread concept | Lock concept in thread |
| 1. | Synchronized thread concept built into java programming language | Lock concept interface used from concurrency libraries package |
| 2. | Synchronized thread automatically releases the monitor, when leaving the synchronized block/method | You need to must explicitly call unlock() function or method for it |
| 3. | Synchronized thread concept simpler to use in java thread | Lock concept is more flexible to use with java thread task |
| 4. | Synchronized thread concept support no trylock() method | Lock concept supports trylock() function method |
| 5. | Synchronized thread concept provide less control | Lock concept provides us more control over lock acquisition |
Example of a Java thread task lock.
एक जावा एक्सप्रेशन में tryLock() फंक्शन मेथड एक थ्रेड को बिना ज़्यादा वेट किए लॉक लेने की कोशिश करने देता है।
if (lock.tryLock()) {
try {
// critical lock wait section
} finally {
lock.unlock();
}
}
Semaphore with java.util.concurrent class.
जावा थ्रेड में एक सेमाफोर एक फिक्स्ड नंबर्स में परमिट का यूज़ करके किसी सिस्टम डाटा रिसोर्स के एक्सेस को कंट्रोल करता है।
इसे जावा यूजर एक टिकट की लिमिटेड नंबर्स वैल्यू के रूप में सोचें।
Semaphore Thread instance.
Semaphore semaphore = new Semaphore(4);
इसका मतलब है कि स्टार्ट में ज़्यादा से ज़्यादा 4 थ्रेड टास्क परमिट अवेलेबल हैं।
जिसमे एक ही समय में 4 थ्रेड टास्क तक परमिट ले सकते हैं।
Semaphore Java Thread Task instance.
import java.util.concurrent.Semaphore;
class Resource {
private final Semaphore semaphore =
new Semaphore(3);
void useResource() {
try {
semaphore.acquire();
System.out.println(
Thread.currentThread().getName()
+ ” this is use the thread task resource”
);
Thread.sleep(3000);
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
} finally {
semaphore.release();
}
}
}
Explaining the Semaphore Java Thread Task.
यहाँ इस कंडीशन में जावा डेवलपर क्रिएट करते हैं.
Semaphore semaphore = new Semaphore(3);
यहाँ स्टार्ट में 3 परमिट होते हैं।
जिसमे एक थ्रेड परमिट के लिए रिसोर्स से रिक्वेस्ट करता है.
semaphore.acquire();
यदि मौजूदा टास्क रिसोर्स में परमिट अवेलेबल है, तो थ्रेड अपने आप कंटिन्यू होता रहता है।
यदि थ्रेड रिसोर्सेज में कोई परमिट अवेलेबल नहीं है, तो इस कंडीशन में थ्रेड वेट करता है।
इसमें थ्रेड टास्क के रिसोर्स यूज़ करने के बाद, यह परमिट रिलीज़ करता है.
semaphore.release();
Semaphore concept in a Java Thread Task.
यहाँ माना की जावा थ्रेड टास्क रिसोर्स में 3 परमिट हैं.
Semaphore thread task
|
+— Permit Request 1 → Thread Task P
|
+— Permit Request 2 → Thread Task Q
|
+— Permit Request 3 → Thread Task R
अगर यहाँ इस एक्साम्प्ल में Thread task S परमिट लेने की कोशिश करता है. तो
Thread S → acquire()
|
v
No permit available
|
WAIT for permit
जब Thread P अपना परमिट रिलीज़ करता है.
Thread P → release()
|
v
परमिट उपलब्ध है
|
v
थ्रेड S जारी है
Real-life example in a Java thread.
सोचिए एक कंपनी या आर्गेनाइजेशन है, जिसमें 4 फ्रेश एम्प्लॉई जॉब वेकन्सी अवेलेबल हैं।
फ्रेश एम्प्लॉई वेकन्सी की जगहें है = 4
एम्प्लॉई P → जॉब के लिए अंदर जाता है
एम्प्लॉई Q → जॉब के लिए अंदर जाता है
एम्प्लॉई R → जॉब के लिए अंदर जाता है
एम्प्लॉई S → थ्रेड टास्क लिस्ट में वेट करता है
जब कंपनी में से एक एम्प्लॉई निकलता है, तो एम्प्लॉई S के लिए जगह उपलब्ध हो जाती है।
यह कांसेप्ट ठीक वैसे ही है, जैसे सेमाफोर काम करता है।
CountDownLatch with the java.util.concurrent class.
जावा थ्रेड टास्क में एक CountDownLatch एक या ज़्यादा थ्रेड्स टास्क को तब तक वेट करने में हेल्प करता है, जब तक कि एक फिक्स्ड नंबर्स में थ्रेड टास्क ऑपरेशन कम्पलीट न हो जाएं।
इस प्रोसेस को एक काउंट से स्टार्ट किया जाता है.
CountDownLatch latch = new CountDownLatch(4);
इस कंडीशन में हर टास्क में कम्पलीट हुआ एक थ्रेड ऑपरेशन काउंट को कम करता है, इस कांसेप्ट का इस्तेमाल करके।
latch.countDown();
जावा प्रोग्राम में एक वेटिंग थ्रेड टास्क को कॉल करता है.
latch.await();
जब थ्रेड काउंट ज़ीरो वैल्यू पर पहुंच जाता है, तो वेटिंग थ्रेड को कंटिन्यू रखने की परमिशन प्रोवाइड कि जाती है।
CountDownLatch Java thread instance.
import java.util.concurrent.CountDownLatch;
public class Main {
public static void main(String[] args)
throws InterruptedException {
CountDownLatch latch =
new CountDownLatch(4);
Thread tsk1 = new Thread(() -> {
System.out.println(“Thread Task 1 done”);
latch.countDown();
});
Thread tsk2 = new Thread(() -> {
System.out.println(“Thread Task 2 done”);
latch.countDown();
});
Thread tsk3 = new Thread(() -> {
System.out.println(“Thread Task 3 done”);
latch.countDown();
});
Thread tsk4 = new Thread(() -> {
System.out.println(“Thread Task 4 done”);
latch.countDown();
});
tsk1.start();
tsk2.start();
tsk3.start();
tsk4.start();
latch.await();
System.out.println(
“All above thread tasks done, Main thread is continues.”
);
}
}
How this works in a Java program
स्टार्ट में इसमें में.
Count = 4
जब थ्रेड टास्क 1 टर्मिनेट होता है.
countDown()
Count = 2
जब थ्रेड टास्क 2 टर्मिनेट होता है.
countDown()
Count = 1
जब थ्रेड टास्क 3 टर्मिनेट होता है.
countDown()
Count = 0
अब अन्य मेन थ्रेड, जो इस टास्क पर वेट कर रहा था.
latch.await();
तो इसमें थ्रेड एग्ज़िक्यूशन कंटिन्यू रखता है।
Essential feature of CountDownLatch in Java thread task.
जावा थ्रेड टास्क में CountDownLatch सामान्य रूप से एक वन-शॉट होता है।
एक बार जब थ्रेड काउंट वैल्यू ज़ीरो पर पहुँच जाता है, तो इसे रीसेट नहीं किया जा सकता है।
दोबारा यूज़ होने वाले थ्रेड सिंक्रोनाइज़ेशन बैरियर के लिए, Java CyclicBarrier प्रोवाइड करता है, और जिसका पर्पस अलग है।
Difference Between Lock, Semaphore, and CountDownLatch in java thread task method
| Each Feature | Lock concept | Semaphore concept | CountDownLatch concept |
| What is purpose | lock Protect thread task shared resource | Semaphore Limit concurrent thread task resources access | CountDownLatch Wait for tasks/events to complete until next come |
| Controls provide | It provides Mutual exclusion features support | It limits fixed Number of thread task permits in availability | It Completion available thread task to count |
| Which methods | It used lock(), unlock() function or method | It used acquire(), release() function or method | It used await(), countDown()function or method to work |
| Multiple threads can proceed? | This is Usually one per lock features supported | Yes, it supports up to permit count value reach start to 0 value | It Waiting threads task proceed when count reaches 0 numbers |
| Reusable? Or not | Yes, Lock thread task | Yes, Semaphore thread task | CountDownLatch thread task No, normally one-shot |
| Where is General use | It Protect critical thread task section | It used to Connection/resource pool | It Wait for multiple thread tasks mechanism |
A simple comparison between a Java thread task lock, semaphore, and CountDownLatch in real life.
Lock Java thread features.
लोक जावा कंडीशन के लिए जावा यूजर एक सिंगल रूम वाले बाथरूम को इमेजिन करें।
1 रूम की → एक बार में केवल 1 इंडिविजुअल यूजर ही इसे यूज़ कर सकता है.
जिसमे एक थ्रेड लॉक को लेता है, और इसके रिसोर्स का यूज़ करता है, फिर उसे जरूरत पड़ने पर रिलीज़ करता है। और फिर लॉक = एक-एक करके एक्सेस करता है।
Semaphore Java thread features.
सेमाफोर जावा कंडीशन के लिए जावा यूजर एक पार्किंग लॉट को इमेजिन करे, जिसमें 10 स्पेस लोकेशन हैं.
10 बाइक परमिट → 10 बाइक्स अंदर आ सकती हैं.
जैसे ही इस प्रोसेस में 11 वि बाइक अंदर जाती है, तब उस बाइक को तब तक वेट करना होगा, जब तक की मौजूदा पार्किंग में एक स्पेस खाली न हो जाए।
सेमाफोर = जिसमे एक साथ लिमिटेड नंबर्स में यूज़र।
CountDownLatch Java thread features.
काउंटडाउनलैच जावा कंडीशन के लिए जावा यूजर इमेजिन करे, एक मीटिंग स्टार्ट करने से पहले 5 टीम मेंबर एम्प्लॉई के आने का वेट करना है.
एम्प्लॉई 1 आता है → काउंट = 4
एम्प्लॉई 2 आता है → काउंट = 3
एम्प्लॉई 3 आता है → काउंट = 2
एम्प्लॉई 4 आता है → काउंट = 1
एम्प्लॉई 5 आता है → काउंट = 0
↓
एम्प्लॉई मीटिंग शुरू होती है
काउंटडाउनलैच = ज़रूरी इवेंट/टास्क पूरे होने तक वेट करता है।
Easy way to remember locks, semaphores, and CountDownLatch in Java threads.
- Lock → यह थ्रेड टास्क के रिसोर्स को प्रोटेक्ट करता है.
- Semaphore → यह थ्रेड टास्क में यूज़र्स के नंबर्स को लिमिट करता है.
- CountDownLatch → यह थ्रेड टास्क टर्मिनेट होने का वेट करता है.
Conclusion of Locks, Semaphores, CountDownLatch.
जावा थ्रेड टास्क में लॉक एक सिंक्रोनाइज़ेशन मैकेनिज्म या मेथड है, जिसका यूज़ जावा थ्रेड म्यूचुअल एक्सक्लूजन प्रोवाइड करने और एक क्रिटिकल सेक्शन को कई थ्रेड्स द्वारा एक साथ एक्सेस से प्रोटेक्ट करने में किया जाता है। जिसमे मुख्य रूप से रीएंट्रेंटलॉक, लॉक इंटरफ़ेस का एक सामान्य रूप से यूज़ होने वाला इम्प्लीमेंटेशन है।
सेमाफोर जावा थ्रेड कांसेप्ट में एक फिक्स्ड नंबर के परमिट का यूज़ करके टास्क रिसोर्स के एक्सेस को कंट्रोल करता है। थ्रेड्स एक्वायर() फंक्शन का यूज़ करके परमिट लेते हैं, और उन्हें रिलीज़() फंक्शन मेथड का यूज़ करके वापस करते हैं। यह फीचर्स तब यूज़ किया जाता है, जब लिमिटेड नंबर के थ्रेड्स टास्क को एक साथ अवेलेबल थ्रेड रिसोर्स को एक्सेस करना चाहिए।
जावा थ्रेड कांसेप्ट में काउंटडाउनलैच एक सिंक्रोनाइज़ेशन एड मेथड है, जो सिस्टम या रिसोर्सेज में एक या ज़्यादा थ्रेड्स टास्क को तब तक वेट करने में हेल्प करता है. जब तक कि एक फिक्स्ड नंबर के ऑपरेशन कम्पलीट न हो जाएं। काउंट को काउंटडाउन() फंक्शन मेथड का यूज़ करके कम किया जाता है, और जब काउंट ज़ीरो वैल्यू पर पहुँच जाता है, तो फाइनल वेट कर रहे थ्रेड्स टास्क रिलीज़ हो जाते हैं।
One-line summary of Locks, Semaphores, and CountDownLatch.
- Lock → इस जावा थ्रेड टास्क में कौन एंटर कर सकता है?, यह मैनेज होता है.
- Semaphore → इस जावा थ्रेड टास्क में कितने नंबर्स एंटर कर सकते हैं?, यह फिक्स्ड होता है.
- CountDownLatch → इस जावा थ्रेड टास्क में मैं कब जारी रख सकता हू, यह फिक्स्ड और मैनेज होता है.
