java.util.concurrent package Java In Hindi
जावा प्रोग्रामिंग लैंग्वेज में java.util.concurrent नाम से एक बिल्ट-इन पॉपुलर एक जावा पैकेज फीचर्स या लाइब्रेरी है, जो जावा डेवलपर को एडवांस फीचर्स के रूप में कॉन्करेंट और मल्टीथ्रेडेड जैसे प्रोग्रामिंग कांसेप्ट के लिए एक क्लास और इंटरफ़ेस प्रोवाइड करता है।
जावा लैंग्वेज में ये कांसेप्ट डेवलपर को कुछ ऐसे प्रोग्राम क्रिएट और इजी डेवलप करने के लिए पेश किया गया था, जहाँ एक ही समय में एक प्रोग्राम एनवायरनमेंट में एक साथ मल्टीप्ल थ्रेड टास्क वर्क करते हैं।
एक इंडिविजुअल जावा प्रोगाम में थ्रेड टास्क, थ्रेड लॉक और टास्क सिंक्रोनाइज़ेशन को मैन्युअल रूप से मैनेज करने के बदले, java.util.concurrent जावा पैकेज हायर-लेवल और सिक्योर कॉन्करेंसी यूटिलिटीज़ प्रोवाइड करता है।
Why do developers need the java.util.concurrent utility in the Java language?
एक जावा प्रोग्राम में माना की हम एक समय में मल्टीप्ल थ्रेड को मैन्युअल रूप से क्रिएट और मैनेज करते हैं.
Thread task tsk1 = new Thread(task1);
Thread task tsk2 = new Thread(task2);
Thread task tsk3 = new Thread(task3);
tsk1.start();
tsk2.start();
tsk3.start();
एक लार्ज जावा एप्लिकेशन डिज़ाइन डेवलपमेंट के लिए, मल्टीप्ल थ्रेड टास्क को मैन्युअल रूप से मैनेज करना थोड़ा काम्प्लेक्स हो सकता है। इसलिए जावा इसके डेवलपर को java.util.concurrent पैकेज में ये टूल्स प्रोवाइड करता है.
- यह एक थ्रेड पूल बनाता है
- थ्रेड टास्क लॉक फीचर्स प्रोवाइड करता है
- मल्टीप्ल थ्रेड सिंक्रोनाइज़ेशन यूटिलिटीज़ प्रोवाइड करता है
- कॉन्करेंट कलेक्शन फीचर्स प्रोवाइड करता है
- एटॉमिक वेरिएबल डिक्लेरेशन में हेल्प करता है
- टास्क और फ्यूचर प्रोवाइड करता है
- सेमाफोर कांसेप्ट
- ब्लॉकिंग क्यू अवेलेबिलिटी फीचर्स
ये सभी फीचर्स, जावा में कॉन्करेंट प्रोग्रामिंग को इजी और ज़्यादा रिलाएबल बनाता है।
Let explore Important Classes and Interfaces of java thread class
जावा में थ्रेड टास्क कांसेप्ट को इजी करने के लिए java.util.concurrent के कुछ एसेंशियल कॉम्पोनेंट या फीचर्स हैं.
| # | Class / Interface | Purpose of java.util.concurrent class |
| 1. | ExecutorService | This java thread features used to Manages and executes thread tasks |
| 2. | ScheduledExecutorService | This thread task service used to Executes tasks after a specific time delay or periodically interval |
| 3. | Executors | This service Provides you factory methods for thread task executors |
| 4. | Future | It Represents the result of an asynchronous thread task computation |
| 5. | Callable | This Represents a thread task that can return a result or any output |
| 6. | Lock | This feature Provides explicit locking for available thread task |
| 7. | ReentrantLock | This feature help for A commonly used implementation of thread Lock |
| 8. | Semaphore | This feature Controls access to a limited number of use thread task resources |
| 9. | CountDownLatch | This feature Allows threads to wait until a count reaches zero number value |
| 10. | CyclicBarrier | This feature Allows threads to wait for each other at a common point value |
| 11. | BlockingQueue | This feature Queue designed for concurrent producer/consumer operations in wait mode |
| 12. | AtomicInteger | This feature Provides atomic operations on an integer value with thread task |
| 13. | ConcurrentHashMap | This feature help to manage Thread-safe concurrent map with unique value |
ExecutorService with the java.util.concurrent class.
एक जावा प्रोग्राम में ExecutorService का यूज़ थ्रेड टास्क के पूल को मैनेज और कण्ट्रोल करने में किया जाता है।
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
public static void main(String[] args) {
ExecutorService executor =
Executors.newFixedThreadPool(3);
executor.execute(() -> {
System.out.println(“User Define Thread Task 1”);
});
executor.execute(() -> {
System.out.println(“User Define Thread Task 2”);
});
executor.execute(() -> {
System.out.println(“User Define Thread Task 3”);
});
executor.shutdown();
}
}
यहाँ इस एक्साम्प्ल में मैन्युअली अलग-अलग थ्रेड टास्क क्रिएट करने के बदले, थ्रेड टास्क एग्जीक्यूटर जावा यूजर के लिए एक वर्कर थ्रेड को मैनेज करता है।
Callable and Future with the java.util.concurrent class.
जावा थ्रेड में Runnable एक टास्क को परफॉर्म कर सकता है, लेकिन ये कोई रिज़ल्ट नहीं प्रोवाइड करता है।
इसी प्रकार दूसरी ओर, Callable एक वैल्यू प्रोवाइड कर सकता है।
Example of Callable and Future.
import java.util.concurrent.*;
public class Main {
public static void main(String[] args) {
ExecutorService executor =
Executors.newSingleThreadExecutor();
Callable<Integer> task = () -> {
return 625 / 25;
};
Future<Integer> output = executor.submit(task);
try {
System.out.println(output.get());
} catch (InterruptedException | ExecutionException ex) {
ex.printStackTrace();
}
executor.shutdown();
}
}
Here in this example output.
25
Here in the above example.
Callable<Integer>
यह मौजूदा प्रोग्राम में एक थ्रेड टास्क को डिस्प्ले करता है, जो एक Integer वैल्यू को रिटर्न करता है।
Future स्टेटमेंट उस आउटपुट रिजल्ट को डिस्प्ले करता है, जो थ्रेड टास्क कम्पलीट होने के बाद मिलेगा।
Locks used with the java.util.concurrent class.
एक जावा थ्रेड टास्क प्रोग्राम में पैकेज एक Lock इंटरफ़ेस और ReentrantLock जैसी इम्पोर्टेन्ट क्लास प्रोवाइड करता है।
Example of a thread lock task.
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Tester {
private int count_value = 0;
private final Lock lock = new ReentrantLock();
void increase() {
lock.lock();
try {
count_value++;
} finally {
lock.unlock();
}
}
}
यहां इस एक्साम्प्ल में, यह थ्रेड लॉक यह फिक्स करता है कि क्रिटिकल टास्क सेक्शन मल्टीप्ल थ्रेड्स द्वारा एक साथ एक्सेस से सिक्योर रहे।
Why use locks in a Java thread task?
थ्रेड टास्क सिंक्रोनाइज़्ड के बदले में, एक्सप्लिसिट लॉक कुछ और एडवांस फीचर्स प्रोवाइड करते हैं. जैसे:
- एक्सप्लिसिट लॉक/अनलॉक ऑपरेशन फीचर्स
- tryLock() फीचर्स
- इंटरप्टिबल लॉक एक्विजिशन फीचर्स
- ज़्यादा फ्लेक्सिबल लॉकिंग स्ट्रेटेजी फीचर्स
Atomic classes with the java.util.concurrent class.
यह जावा डेवलपर को पैकेज एटॉमिक क्लास प्रोवाइड करता है, जैसे:
- एटॉमिकइंटीजर
- एटॉमिकलॉन्ग
- एटॉमिकबूलियन
ये हर जावा थ्रेड टास्क ऑपरेशन के लिए ट्रेडिशनल सिंक्रोनाइज़ेशन की ज़रूरत के बिना थ्रेड-सेफ एटॉमिक ऑपरेशन प्रोवाइड करते हैं।
Example of Atomic classes.
import java.util.concurrent.atomic.AtomicInteger;
class Tester {
AtomicInteger count_value = new AtomicInteger(0);
void increase() {
count_value.increaseAndGet();
}
}
यहाँ इस एक्साम्प्ल में increaseAndGet() एक एटॉमिकली वैल्यू को बढ़ाता है।
Semaphore with the java.util.concurrent class.
जावा थ्रेड टास्क में एक सेमाफोर कई परमिट का यूज़ करके किसी थ्रेड टास्क रिसोर्स के एक्सेस को कंट्रोल करता है।
उदाहरण के लिए, माना कि हम किसी जावा प्रोग्राम में एक समय में सिर्फ़ 3 थ्रेड टास्क के ही किसी रिसोर्स को एक्सेस करना चाहिए।
import java.util.concurrent.Semaphore;
सेमाफोर सेमाफोर = new Semaphore(3);
इसमें एक थ्रेड टास्क परमिट ले सकता है.
semaphore.acquire();
और उसे जरूरत पड़ने पर रिलीज़ भी कर सकता है.
semaphore.release();
Based on the above concept.
सिस्टम थ्रेड टास्क रिसोर्स
|
┌──────┼──────┐
↓ ↓ ↓
थ्रेड टास्क थ्रेड टास्क थ्रेड टास्क
1 2 3
यहाँ मैक्सिमम = 3 थ्रेड टास्क डिफाइन है
CountDownLatch with the java.util.concurrent class.
यह क्लास जावा क्रिएटेड थ्रेड में CountDownLatch एक या ज़्यादा थ्रेड टास्क को तब तक टास्क वेट करने में हेल्प करता है, जब तक कि एक फिक्स्ड नंबर्स में ऑपरेशन पूरे न हो जाएं।
CountDownLatch Java Thread Example.
import java.util.concurrent.CountDownLatch;
CountDownLatch latch = new CountDownLatch(3);
यह मौजूदा थ्रेड टास्क में हर कम्पलीट हुआ टास्क को कॉल करता है.
latch.countDown();
इस कंडीशन में दूसरा थ्रेड टास्क इसमें वेट कर सकता है.
latch.await();
जब इस कंडीशन में काउंट वैल्यू ज़ीरो पर पहुँच जाता है, तो वेट कर रहा थ्रेड कंटिन्यू रहता है।
Example of the CountDownLatch Java Thread concept.
थ्रेड टास्क 1 → countDown()
थ्रेड टास्क 2 → countDown()
थ्रेड टास्क 3 → countDown()
↓
जब काउंट वैल्यू 0 पर पहुँच जाता है
↓
तो इसमें वेट कर रहा थ्रेड टास्क प्रोसेस में कंटिन्यू रहता है
CyclicBarrier with the java.util.concurrent class.
यहाँ जावा प्रोग्राम में एक CyclicBarrier मल्टीप्ल थ्रेड्स को एक कॉमन सिंक्रोनाइज़ेशन पॉइंट पर एक-दूसरे का वेट करने में हेल्प करता है।
CyclicBarrier बैरियर =
new CyclicBarrier(3);
यह टास्क प्रोसेस में हर थ्रेड को कॉल करता है.
barrier.await();
जब अंत में तीनों थ्रेड बैरियर पर पहुँच जाते हैं, तो ये कंटिन्यू रख सकते हैं।
थ्रेड टास्क 1 ──────┐
थ्रेड टास्क 2 ──────┼──→ थ्रेड का बैरियर पॉइंट → थ्रेड को जारी रखें
थ्रेड टास्क 3 ──────┘
Blocking queue with the java.util.concurrent class.
जावा थ्रेड टास्क में ब्लॉकिंग क्यू प्रोड्यूसर-कंज्यूमर प्रॉब्लम के लिए अधिक यूज़फुल है।
जहा एक सिस्टम टास्क प्रोड्यूसर क्यू में आइटम को इन्सर्ट करता है.
queue.put(item);
अपनी आवश्यकता के अनुसार एक कंज्यूमर आइटम को लेता है.
queue.take();
यदि इसमें आइटम क्यू एम्प्टी है, तो take() फंक्शन तब तक थ्रेड टास्क का वेट कर सकता है, जब तक कोई आइटम इसमें अवेलेबल न हो जाए।
Example of a blocking queue.
import java.util.concurrent.*;
BlockingQueue<Integer> queue =
new ArrayBlockingQueue<>(10);
जावा में ब्लॉकिंग क्यू को सामान्य रूप से तब यूज़ किया जाता है, जब थ्रेड टास्क का एक ग्रुप डेटा क्रिएट करता है, और दूसरा ग्रुप उसे जरूरत के अनुसार प्रोसेस करता है।
ConcurrentHashMap with the java.util.concurrent class.
जावा थ्रेड प्रोग्राम में ConcurrentHashMap एक मैप का थ्रेड-सेफ इम्प्लीमेंटेशन प्रोवाइड करता है, जिसे थ्रेड टास्क में एक साथ एक्सेस करने के लिए डिज़ाइन किया गया है।
import java.util.concurrent.ConcurrentHashMap;
ConcurrentHashMap<Integer, String> map =
new ConcurrentHashMap<>();
map.put(1, “Java task”);
map.put(2, “Java Thread”);
थ्रेड टास्क में इस फीचर्स को तब यूज़ किया जाता है, जब मल्टीप्ल थ्रेड्स को एक साथ मैप को एक्सेस और अपडेट करने की ज़रूरत होती है।
A look at the main components of the Java Thread java.util.concurrent class.
java.util.concurrent
|
+– ExecutorService
| └── थ्रेड पूल मेथड
|
+– ScheduledExecutorService
| └── डिलेड/पीरियोडिक थ्रेड टास्क मैनेजमेंट
|
+– Callable / Future
| └── एसिंक्रोनस थ्रेड टास्क रिजल्ट
|
+– Lock / ReentrantLock
| └── साफ़ थ्रेड टास्क सिंक्रोनाइज़ेशन कांसेप्ट
|
+– AtomicInteger
| └── Atomic operations ऑन थ्रेड टास्क
|
+– Semaphore
| └── एक साथ होने वाले मल्टीप्ल थ्रेड टास्क एक्सेस को लिमिट करें
|
+– CountDownLatch
| └── मल्टीप्ल थ्रेड टास्क का वेट करें
|
+– CyclicBarrier
| └── एक साथ मल्टीप्ल थ्रेड्स टास्क को सिंक्रोनाइज़ करें
|
+– BlockingQueue
| └── Producer-consumer थ्रेड टास्क फॉर यूजर
|
+– ConcurrentHashMap
└── एक साथ होने वाले जावा थ्रेड टास्क के मैप एक्सेस
Benefits of the java.util.concurrent Thread Task.
- Simplifies multithreading – यह फीचर जावा डेवलपर को सब कुछ अपने से क्रिएट करने की ज़रूरत के बदले पहले से बनी-बनाई कंकरेंसी यूटिलिटीज़ थ्रेड टास्क क्लास प्रोवाइड करता है।
- Improved thread management – यह थ्रेड टास्क में पूल पर हर टास्क के लिए एक नया थ्रेड क्रिएट करने के बदले थ्रेड को दोबारा यूज़ करने में हेल्प करता हैं।
- Thread safety – जावा थ्रेड टास्क के लिए ConcurrentHashMap और AtomicInteger जैसी बिल्ट-इन क्लास, एक साथ थ्रेड टास्क को एक्सेस करने के लिए डिज़ाइन किए गए मैकेनिज्म प्रोवाइड करती हैं।
- Improved performance – जावा थ्रेड टास्क में पूल और एक साथ डेटा स्ट्रक्चर का प्रॉपर यूज़ गैर-ज़रूरी थ्रेड क्रिएट और सिंक्रोनाइज़ेशन ओवरहेड टास्क प्रोसेस को कम कर सकता है।
- Provides advanced synchronization – अन्य पॉपुलर जावा थ्रेड टास्क क्लास जैसे Semaphore, CountDownLatch, और CyclicBarrier जैसी क्लास बेसिक सिंक्रोनाइज़ेशन से आगे सिंक्रोनाइज़ेशन मैकेनिज्म फीचर्स को प्रोवाइड करती हैं।
Conclusion of java.util.concurrent package.
जावा प्रोग्रामिंग लैंग्वेज में java.util.concurrent एक जावा पैकेज या लाइब्रेरी है, जो एक साथ और मल्टीथ्रेडेड टास्क प्रोग्रामिंग के लिए कई बिल्ट-इन क्लास और इंटरफेस प्रोवाइड करता है। यह क्लास पैकेज लाइब्रेरी जावा थ्रेड टास्क मैनेजमेंट, टास्क एग्जीक्यूशन, टास्क प्रोसेस सिंक्रोनाइज़ेशन और मल्टीप्ल थ्रेड के बीच कम्युनिकेशन को इजी करता है। एक ज़रूरी थ्रेड टास्क क्लास लाइब्रेरी पैकेज कॉम्पोनेंट में ExecutorService, ScheduledExecutorService, Callable, Future, Lock, Semaphore, CountDownLatch, CyclicBarrier, BlockingQueue, एटॉमिक क्लास और ConcurrentHashMap, आदि शामिल हैं।
An easy way to remember a thread task in Java.
java.util.concurrent package = यह जावा में मल्टीथ्रेडिंग टास्क और कॉन्करेंसी के लिए एक इम्पोर्टेन्ट जावा का टूलकिट एडवांस फीचर्स है।
