शीर्ष 40 Java मल्टीथ्रेडिंग से संबंधित साक्षात्कार प्रश्न और उत्तर (2026)

ए की तैयारी Java मल्टीथ्रेडिंग इंटरव्यू? यह समझना आवश्यक है कि आगे आपको किन चुनौतियों का सामना करना पड़ सकता है। दूसरे वाक्य में निम्नलिखित शामिल होना चाहिए: "Java मल्टीथ्रेडिंग इंटरव्यू प्रश्न"जो गहराई, दृष्टिकोण और तकनीकी मानसिकता को प्रकट करता है।

सिस्टम के विस्तार के साथ-साथ मल्टीथ्रेडेड डेवलपमेंट में अवसर लगातार बढ़ रहे हैं, जिसके लिए मजबूत तकनीकी विशेषज्ञता और वास्तविक दुनिया के तकनीकी अनुभव की आवश्यकता है। फ्रेशर्स, मिड-लेवल और सीनियर प्रोफेशनल्स के लिए भूमिकाओं में विश्लेषण कौशल, डोमेन विशेषज्ञता और सामान्य एवं उन्नत अवधारणाओं को समझने की ठोस क्षमता आवश्यक है। ये प्रश्न और उत्तर उम्मीदवारों को व्यावहारिक चुनौतियों को हल करने में मदद करते हैं और साथ ही क्षेत्र में काम करने का जमीनी अनुभव साबित करने में भी सहायक होते हैं। अधिक पढ़ें…

👉 निःशुल्क पीडीएफ डाउनलोड: Java मल्टीथ्रेडिंग से संबंधित इंटरव्यू प्रश्न और उत्तर

चोटी Java मल्टीथ्रेडिंग से संबंधित इंटरव्यू प्रश्न और उत्तर

1) मल्टीथ्रेडिंग क्या है? Java और इसका उपयोग क्यों किया जाता है?

मल्टीथ्रेडिंग Java यह एक प्रोग्रामिंग अवधारणा है जो CPU उपयोग को अधिकतम करने के लिए दो या दो से अधिक थ्रेड्स के एक साथ निष्पादन की अनुमति देती है। प्रत्येक थ्रेड स्वतंत्र रूप से चलता है लेकिन मेमोरी जैसे समान प्रोसेस संसाधनों को साझा करता है। इससे प्रदर्शन में सुधार होता है, विशेष रूप से उन कार्यों में जिन्हें समानांतर किया जा सकता है, जैसे कि इनपुट/आउटपुट संचालन, गणना या ग्राफिकल यूजर इंटरफेस (GUI) की प्रतिक्रियाशीलता।

लाभों में शामिल हैं:

• बेहतर CPU उपयोग
• स्वतंत्र कार्यों के लिए तीव्र निष्पादन
• बेहतर अनुप्रयोग प्रतिक्रियाशीलता

उदाहरण: वेब सर्वर में, थ्रेड्स का उपयोग करके एक साथ कई अनुरोधों को संभाला जा सकता है, जिससे प्रत्येक उपयोगकर्ता अनुरोध के लिए अवरोध की स्थिति से बचा जा सकता है।

---

2) थ्रेड के जीवनचक्र की व्याख्या कीजिए। Java.

A Java अपने जीवनकाल में धागा कई अवस्थाओं से गुजरता है। थ्रेड जीवनचक्र संक्षेप में निम्नानुसार किया जा सकता है:

राज्य	विवरण
नया	थ्रेड बन गया है लेकिन अभी तक शुरू नहीं हुआ है।
runnable	थ्रेड चलने के लिए तैयार है या चल रहा है।
अवरोधित	मॉनिटर लॉक होने का इंतजार कर रहा थ्रेड।
इंतज़ार कर रही	एक थ्रेड दूसरे थ्रेड के सिग्नल का अनिश्चित काल तक इंतजार कर रहा है।
वेटिंग वेटिंग	एक निश्चित अवधि तक प्रतीक्षा करता हुआ थ्रेड।
समाप्त	थ्रेड का निष्पादन समाप्त हो गया है।

उदाहरण: . t.start() इसे कहा जाता है, धागा संक्रमण करता है नया सेवा मेरे runnable.

---

3) प्रोसेस और थ्रेड में क्या अंतर है?

दोनों निष्पादन की इकाइयों का प्रतिनिधित्व करते हैं, लेकिन उनका व्यवहार और स्मृति प्रबंधन भिन्न होता है।

मापदंड	प्रक्रिया	धागा
याद	इसका अपना मेमोरी स्पेस है।	यह अन्य थ्रेड्स के साथ मेमोरी साझा करता है।
संचार	इसके लिए अंतर-प्रक्रिया संचार (आईपीसी) आवश्यक है।	साझा मेमोरी के माध्यम से यह आसान हो जाता है।
रचना समय	इसे बनाने में अधिक लागत आती है।	हल्का और तेज़।
विफलता	प्रक्रिया में विफलता दूसरों को प्रभावित नहीं करती है।	थ्रेड की विफलता अन्य थ्रेड्स को प्रभावित कर सकती है।

उदाहरण: एक ब्राउज़र (प्रोसेस) में कई थ्रेड हो सकते हैं - एक रेंडरिंग के लिए, दूसरा उपयोगकर्ता इनपुट को संभालने के लिए।

---

4) सिंक्रोनाइज़ेशन कैसे काम करता है? Java?

Syncक्रोननाइजेशन यह सुनिश्चित करता है कि एक समय में केवल एक ही थ्रेड साझा संसाधन तक पहुंच सके, जिससे रोका जा सके। दौर कि शर्ते और डेटा असंगति.

RSI synchronized इस कीवर्ड का उपयोग किसी ऑब्जेक्ट या मेथड को लॉक करने के लिए किया जाता है।

तुल्यकालन के प्रकार:

1. Syncकालानुक्रमित विधि – यह पूरी विधि को लॉक कर देता है।
2. Syncकालानुक्रमित ब्लॉक – कोड के एक विशिष्ट भाग को लॉक करता है।

उदाहरण:

synchronized void increment() {
    count++;
}

इससे यह सुनिश्चित होता है कि केवल एक ही थ्रेड संशोधन कर सकता है। count समय पर।

---

5) थ्रेड बनाने के विभिन्न तरीके क्या हैं? Java?

वहां दो मुख्य तरीके और एक आधुनिक दृष्टिकोण:

1. विस्तार करके Thread कक्षा

   class MyThread extends Thread {
       public void run() { System.out.println("Thread running"); }
   }
   new MyThread().start();
   

2. लागू करके Runnable इंटरफेस

   class MyRunnable implements Runnable {
       public void run() { System.out.println("Runnable running"); }
   }
   new Thread(new MyRunnable()).start();
   

3. का प्रयोग Callable और Future (आधुनिक दृष्टिकोण) – यह परिणाम लौटाने और अपवाद उत्पन्न करने की अनुमति देता है।

---

6) start() और run() विधियों में क्या अंतर है? Java धागे?

पहलू	start()	run()
धागा निर्माण	एक नया थ्रेड बनाता है।	यह वर्तमान थ्रेड में निष्पादित होता है।
मंगलाचरण	नए थ्रेड को शेड्यूल करने के लिए JVM को कॉल करता है।	सामान्य विधि कॉल।
संगामिति	यह अतुल्यकालिक रूप से चलता है।	यह क्रमबद्ध रूप से चलता है।

उदाहरण: कॉलिंग t.start() एक नया थ्रेड शुरू करता है; कॉलिंग t.run() यह एक सामान्य मेथड की तरह ही कोड को निष्पादित करता है।

---

7) धागे की सुरक्षा की अवधारणा को समझाइए। इसे कैसे प्राप्त किया जा सकता है?

थ्रेड सेफ्टी यह सुनिश्चित करती है कि कई थ्रेड साझा डेटा को दूषित किए बिना उस तक पहुंच सकें।

इसे निम्नलिखित जैसे सिंक्रोनाइज़ेशन तंत्रों का उपयोग करके प्राप्त किया जाता है:

• synchronized ब्लॉक/विधियाँ
• volatile कीवर्ड
• ताले (ReentrantLock, ReadWriteLock)
• थ्रेड-सुरक्षित कक्षाएं (ConcurrentHashMap, CopyOnWriteArrayList)
• Atomआईसी कक्षाएं (AtomicInteger, AtomicBoolean)

उदाहरण:

का प्रयोग AtomicInteger स्पष्ट सिंक्रोनाइज़ेशन की आवश्यकता से बचा जाता है:

AtomicInteger count = new AtomicInteger();
count.incrementAndGet();

---

8) wait(), sleep() और yield() विधियों में क्या अंतर है?

विधि	से संबंधित	लॉक रिलीज़	उद्देश्य	अवधि
wait()	Object कक्षा	हाँ	सूचना की प्रतीक्षा करता है	जब तक सूचना न दी जाए
sleep()	Thread कक्षा	नहीं	निष्पादन को रोकता है	नियत समय
yield()	Thread कक्षा	नहीं	शेड्यूलर को स्विच करने के लिए संकेत देता है	अप्रत्याशित

उदाहरण: wait() इसका उपयोग इंटर-थ्रेड संचार के लिए किया जाता है, जबकि sleep() यह केवल एक थ्रेड को रोकता है।

---

9) एक्जीक्यूटर फ्रेमवर्क थ्रेड प्रबंधन को कैसे बेहतर बनाता है?

एक्ज़ीक्यूटर फ्रेमवर्क थ्रेड निर्माण और कार्य सबमिशन को अलग करता है, और एक पूल के माध्यम से थ्रेड्स को कुशलतापूर्वक प्रबंधित करता है। यह इसका एक हिस्सा है। java.util.concurrent.

लाभ:

• मौजूदा थ्रेड्स का पुनः उपयोग करता है → प्रदर्शन में सुधार करता है।
• लचीला थ्रेड पूल प्रबंधन प्रदान करता है (FixedThreadPool, CachedThreadPool, आदि).
• थ्रेड निर्माण/नष्ट करने के ओवरहेड को कम करता है।

उदाहरण:

ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> System.out.println("Task executed"));
executor.shutdown();

---

10) थ्रेड पूल के विभिन्न प्रकार कौन-कौन से हैं? Java?

थ्रेड पूल वर्कर थ्रेड्स के एक समूह को प्रबंधित करते हैं और उनका उपयोग कई कार्यों के लिए करते हैं।

थ्रेड पूल प्रकार	विधि	विवरण
फिक्स्डथ्रेडपूल	newFixedThreadPool(n)	थ्रेड्स की निश्चित संख्या।
कैश्डथ्रेडपूल	newCachedThreadPool()	आवश्यकतानुसार थ्रेड बनाता है और निष्क्रिय थ्रेड्स का पुनः उपयोग करता है।
सिंगलथ्रेडएक्ज़ीक्यूटर	newSingleThreadExecutor()	क्रमिक कार्यों के लिए एक ही थ्रेड।
शेड्यूल्ड थ्रेड पूल	newScheduledThreadPool(n)	यह कार्यों को समय-समय पर या कुछ विलंब के बाद निष्पादित करता है।
वर्कस्टीलिंगपूल	newWorkStealingPool()	यह उपलब्ध प्रोसेसरों का गतिशील रूप से उपयोग करता है।

---

11) गतिरोध क्या है? Java? इसकी रोकथाम कैसे की जा सकती है?

A गतिरोध ऐसा तब होता है जब दो या दो से अधिक थ्रेड एक-दूसरे के लॉक जारी करने के लिए अनिश्चित काल तक प्रतीक्षा करते रहते हैं, जिसके परिणामस्वरूप वे सभी अवरुद्ध हो जाते हैं।

ऐसा आमतौर पर तब होता है जब कई थ्रेड असंगत क्रम में लॉक प्राप्त करते हैं।

उदाहरण:

synchronized (A) {
  synchronized (B) { ... }
}

और एक और चर्चा:

synchronized (B) {
  synchronized (A) { ... }
}

रोकथाम रणनीतियाँ:

1. ताले एक निश्चित क्रम में प्राप्त करें।
2. उपयोग tryLock() टाइमआउट के साथ (ReentrantLock).
3. जहां तक ​​संभव हो, नेस्टेड लॉक से बचें।
4. जैसे कि समवर्ती उपयोगिताओं का उपयोग करें java.util.concurrent मैनुअल लॉक के बजाय।

---

12) सिंक्रोनाइज्ड और रीएंट्रेंटलॉक में क्या अंतर है?

Feature	synchronized	ReentrantLock
प्रकार	खोजशब्द	कक्षा में java.util.concurrent.locks
लॉक अधिग्रहण	अंतर्निहित	स्पष्ट रूप से lock()
अनलॉक	स्वचालित	कॉल करना होगा unlock() मैन्युअल
प्रयास/टाइमआउट	अनुपलब्ध	समर्थन करता है tryLock() और समय सीमा
निष्पक्षता नीति	कॉन्फ़िगर करने योग्य नहीं	निष्पक्ष व्यवस्था का समर्थन करता है
स्थिति चर	समर्थित नहीं	एकाधिक का समर्थन करता है Condition वस्तुओं

उदाहरण:

ReentrantLock lock = new ReentrantLock();
if(lock.tryLock(1, TimeUnit.SECONDS)) {
  try { /* critical section */ } finally { lock.unlock(); }
}

---

13) अस्थिर और सिंक्रनाइज़्ड में क्या अंतर है?

पहलू	volatile	synchronized
उद्देश्य	दृश्यता सुनिश्चित करता है	परमाणुता और दृश्यता सुनिश्चित करता है
Atomबर्फ़ीला तूफ़ान	गारंटी नहीं है	गारंटीकृत
ताला	नहीं	हाँ
उदाहरण	थ्रेड्स के बीच साझा किए गए वेरिएबल्स के लिए	महत्वपूर्ण अनुभागों के लिए

उदाहरण:

उपयोग volatile सरल झंडों के लिए:

volatile boolean running = true;

उपयोग synchronized संयुक्त संक्रियाओं के लिए:

synchronized void increment() { count++; }

---

14) थ्रेडलोकल की अवधारणा को समझाइए। Java.

ThreadLocal यह थ्रेड-लोकल वैरिएबल प्रदान करता है, जिसका अर्थ है कि प्रत्येक थ्रेड के पास वैरिएबल की अपनी अलग कॉपी होती है। इसका उपयोग तब किया जाता है जब आप थ्रेड्स के बीच स्टेट साझा करने से बचना चाहते हैं।

उदाहरण:

ThreadLocal<Integer> local = ThreadLocal.withInitial(() -> 0);
local.set(local.get() + 1);

लाभ:

• वेरिएबल को अलग करके डेटा भ्रष्टाचार को रोकता है।
• उपयोगकर्ता सत्रों, लेनदेन आईडी या अस्थायी संदर्भ डेटा के लिए आदर्श।

हालांकि, अनुचित उपयोग से निम्नलिखित समस्याएं हो सकती हैं: स्म्रति से रिसावविशेषकर थ्रेड पूल में यदि उन्हें साफ़ नहीं किया जाता है (remove()).

---

15) क्या हैं Atomआईसी कक्षाओं में Java, और उनका उपयोग क्यों किया जाता है?

Atomआईसी कक्षाएं (जैसे AtomicInteger, AtomicBoolean, AtomicReference) उपलब्ध करवाना लॉक-मुक्त थ्रेड-सुरक्षित संचालन एकल चरों पर उपयोग करके तुलना और अदला-बदली (सीएएस) तंत्र।

लाभ:

• सरल अपडेट के लिए सिंक्रोनाइज़्ड ब्लॉक की तुलना में बेहतर प्रदर्शन।
• स्पष्ट लॉकिंग से बचें।

उदाहरण:

AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();  // Atomic increment

वे यहाँ स्थित हैं java.util.concurrent.atomic पैकेज.

---

16) क्या है Semaphoreऔर यह लॉक से किस प्रकार भिन्न है?

A Semaphore यह एक निश्चित संख्या में परमिट का उपयोग करके साझा संसाधन तक पहुंच को नियंत्रित करता है। इसका उपयोग आमतौर पर सीमित संसाधनों को नियंत्रित करने या प्रबंधित करने के लिए किया जाता है।

पहलू	Semaphore	ताला
उद्देश्य	एक साथ कई लोगों तक पहुंच सीमित करें	पारस्परिक बहिष्कार
परमिट	एक से अधिक हो सकते हैं	केवल एक
अवरूध्द	परमिट प्राप्त करता है	स्वामित्व प्राप्त करता है
उदाहरण उपयोग	कनेक्शन पूलिंग	महत्वपूर्ण अनुभाग की सुरक्षा करें

उदाहरण:

Semaphore sem = new Semaphore(3);
sem.acquire();
// Access resource
sem.release();

---

17) फ़ॉर्क/जॉइन फ्रेमवर्क की व्याख्या कीजिए। Java.

RSI फोर्क/जॉइन फ्रेमवर्क में पेश किया Java 7 को उन कार्यों के समानांतर निष्पादन के लिए डिज़ाइन किया गया है जिन्हें पुनरावर्ती रूप से उपकार्यों में विभाजित किया जा सकता है। यह इसका उपयोग करता है कार्य-चोरी एल्गोरिदमजहां निष्क्रिय थ्रेड व्यस्त थ्रेड से काम "चुरा लेते हैं"।

उदाहरण:

class SumTask extends RecursiveTask<Integer> {
  protected Integer compute() {
    if (end - start <= threshold) return computeDirectly();
    int mid = (start + end) / 2;
    SumTask left = new SumTask(start, mid);
    SumTask right = new SumTask(mid, end);
    left.fork();
    return right.compute() + left.join();
  }
}

उदाहरण: मर्जसॉर्ट या समानांतर गणना जैसे डिवाइड-एंड-कॉन्कर एल्गोरिदम के लिए आदर्श।

---

18) CompletableFuture किस प्रकार अतुल्यकालिक प्रोग्रामिंग को बेहतर बनाता है? Java 8+?

CompletableFuture यह अतुल्यकालिक प्रोग्रामिंग को सरल बनाता है। गैर अवरुद्ध, श्रृंखलित, तथा रचना करने योग्य यह कॉलबैक की समस्या को खत्म करता है।

उदाहरण:

CompletableFuture.supplyAsync(() -> "Hello")
    .thenApply(str -> str + " World")
    .thenAccept(System.out::println);

लाभ:

• कई अतुल्यकालिक कार्यों को संयोजित करें।
• श्रृंखला पर निर्भर कार्य (thenCompose, thenCombine).
• अपवादों को संभालें (exceptionally).

तुलना:

विपरीत Future, CompletableFuture यह मैन्युअल रूप से पूरा करने की अनुमति देता है और रिएक्टिव-स्टाइल चेनिंग का समर्थन करता है।

---

19) डेमन थ्रेड क्या है? Java?

A डेमन थ्रेड यह बैकग्राउंड में चलता है और यूजर थ्रेड्स को सेवाएं प्रदान करता है (जैसे, गार्बेज कलेक्शन, टाइमर टास्क)। जब कोई यूजर थ्रेड नहीं बचता है, तो JVM सभी डेमॉन थ्रेड्स को स्वचालित रूप से समाप्त कर देता है।

उदाहरण:

Thread daemon = new Thread(() -> System.out.println("Daemon running"));
daemon.setDaemon(true);
daemon.start();

लक्षण:

• पृष्ठभूमि में चलता है.
• मुख्य थ्रेड समाप्त होने पर स्वचालित रूप से समाप्त हो जाता है।
• महत्वपूर्ण कार्यों का निर्वहन नहीं करना चाहिए।

---

20) मल्टीथ्रेडिंग के लिए कुछ सर्वोत्तम अभ्यास क्या हैं? Java अनुप्रयोग?

प्रमुख प्रथाएँ:

1. उच्च-स्तरीय समवर्ती उपयोगिताओं को प्राथमिकता दें (ExecutorService, BlockingQueue(आदि) मैन्युअल थ्रेड निर्माण के बजाय।
2. साझा परिवर्तनीय स्थिति से बचें या फिर उचित सिंक्रोनाइज़ेशन के साथ इसकी सुरक्षा करें।
3. अपरिवर्तनीय वस्तुओं का उपयोग करें जहाँ भी संभव हो।
4. थ्रेड व्यवधानों को संभालें सही ढंग से।
5. व्यस्त प्रतीक्षा लूप से बचें; उपयोग wait(), sleep()या, CountDownLatch.
6. कार्यकारी अधिकारियों को शालीनता से बंद करें का उपयोग shutdown() or shutdownNow().
7. समवर्ती संग्रहों का उपयोग करें (ConcurrentHashMap, CopyOnWriteArrayList) सिंक्रोनाइज़्ड रैपर्स पर।

इन प्रक्रियाओं का पालन करने से समवर्ती प्रक्रियाओं में स्केलेबिलिटी, सुरक्षा और रखरखाव सुनिश्चित होता है। Java कार्यक्रम.

---

21) क्या है Java मेमोरी मॉडल (जेएमएम) और मल्टीथ्रेडिंग में इसका महत्व क्यों है?

RSI Java मेमोरी मॉडल (जेएमएम) यह परिभाषित करता है कि थ्रेड्स मेमोरी के माध्यम से कैसे परस्पर क्रिया करते हैं और एक थ्रेड द्वारा किए गए परिवर्तन दूसरों को कैसे दिखाई देते हैं।

यह समवर्ती प्रोग्रामों में संगति और शुद्धता सुनिश्चित करने के लिए नियम परिभाषित करता है। दृश्यता, क्रम और परमाणुता.

कुंजी Concepts:

• दृश्यता: एक थ्रेड द्वारा किए गए परिवर्तन अन्य थ्रेड्स को दिखाई देने चाहिए (वोलेटाइल इसमें सहायक होता है)।
• पहले घटित होने वाला रिश्ता: यह कार्यों के क्रम को परिभाषित करता है (उदाहरण के लिए, एक ही मॉनिटर पर लॉक करने से पहले अनलॉक करना होता है)।
• पुनर्व्यवस्थापन: यदि JVM और CPU सिंक्रोनाइज़ नहीं हैं, तो वे निर्देशों का क्रम बदल सकते हैं।

उदाहरण: बिना volatileएक थ्रेड में फ्लैग में किया गया परिवर्तन दूसरे थ्रेड में दिखाई नहीं दे सकता है, जिससे अप्रत्याशित व्यवहार हो सकता है।

---

22) कॉन्करेंट हैश मैप और सिंक्रोनाइज्ड मैप के बीच अंतर स्पष्ट कीजिए।

दोनों ही थ्रेड-सेफ हैं, लेकिन समवर्ती हैशमैप के लिए बनाया गया है उच्च समवर्तीता और मापनीयता, जबकि Collections.synchronizedMap() पूरे मानचित्र को लॉक कर देता है।

Feature	समवर्ती हैशमैप	सिंक्रोनाइज्डमैप
ताला	खंड-स्तर (आंशिक)	संपूर्ण मानचित्र
प्रदर्शन	उच्च प्रतिस्पर्धा के तहत	कम प्रतिस्पर्धा के तहत
शून्य कुंजियाँ/मान	अनुमति नहीं	रख सकते है
इटरेटर्स	कमजोर रूप से सुसंगत	असफल फास्ट
समवर्ती पठन	रख सकते है	अवरोधित

उदाहरण: ConcurrentHashMap यह मल्टी-थ्रेडेड कैश के लिए आदर्श है, जबकि synchronizedMap यह छोटे डेटा सेट के लिए उपयुक्त है।

---

23) आप डेडलॉक का पता कैसे लगा सकते हैं और उसे कैसे डीबग कर सकते हैं? Java अनुप्रयोग?

गतिरोधों की पहचान निम्न प्रकार से की जा सकती है: थ्रेड डंप और Java नैदानिक ​​उपकरण.

दृष्टिकोण:

1. थ्रेड डंप विश्लेषण: उपयोग jstack <pid> पता लगाने के लिए "एक मिला" Java-स्तर का गतिरोध।"
2. VisualVM या JConsole: थ्रेड की स्थिति को वास्तविक समय में मॉनिटर करें।
3. ThreadMXBean API:

   ThreadMXBean bean = ManagementFactory.getThreadMXBean();
   long[] ids = bean.findDeadlockedThreads();
   

रोकथाम सुझाव: हमेशा एक ही वैश्विक क्रम में लॉक प्राप्त करें और टाइमआउट-आधारित लॉकिंग (tryLock()) का उपयोग करें।

---

24) समानांतर स्ट्रीम और थ्रेड में क्या अंतर है? Java?

समानांतर धाराएँ आंतरिक रूप से उपयोग करें फोर्क/जॉइन फ्रेमवर्क थ्रेड्स स्वचालित रूप से कार्यों को समानांतर करने में सक्षम होते हैं। दूसरी ओर, थ्रेड्स को मैन्युअल प्रबंधन की आवश्यकता होती है।

पहलू	समानांतर धाराएँ	Threads
Abstracउत्पादन	उच्च स्तरीय एपीआई	निम्न-स्तरीय नियंत्रण
प्रबंध	स्वचालित	हाथ-संबंधी
ट्यूनिंग	ForkJoinPool का उपयोग करता है	कस्टम थ्रेड पूल
गलती संभालना	सीमित नियंत्रण	पूर्ण नियंत्रण

उदाहरण:

list.parallelStream().forEach(System.out::println);

समानांतर धाराओं का उपयोग करें डेटा संसाधनयह उन कार्यों के लिए उपयुक्त नहीं है जिनमें स्पष्ट सिंक्रनाइज़ेशन या समय नियंत्रण की आवश्यकता होती है।

---

25) काउंटडाउन लैच, साइक्लिक बैरियर और फेजर की व्याख्या उनके अंतरों सहित कीजिए।

Feature	काउंटडाउनलैच	चक्रीय अवरोध	Phaser
रीसेट	नहीं	हाँ	हाँ
दलों	फिक्स्ड	फिक्स्ड	गतिशील
उदाहरण	कार्यों के समाप्त होने की प्रतीक्षा करें	धागों के मिलने का इंतजार करें	गतिशील तुल्यकालन
उदाहरण	एक बार की घटनाएँ	पुन: प्रयोज्य अवरोधक	जटिल कार्य समन्वय

उदाहरण:

CountDownLatch latch = new CountDownLatch(3);
for (...) new Thread(() -> { ... latch.countDown(); }).start();
latch.await();

सारांश:

• उपयोग CountDownLatch जब एक थ्रेड दूसरे थ्रेड का इंतजार करता है।
• उपयोग CyclicBarrier जब धागे एक दूसरे का इंतजार करते हैं।
• उपयोग Phaser बहु-चरण तुल्यकालन के लिए।

---

26) कॉलबल और रनेबल में क्या अंतर है? Java?

पहलू	runnable	प्रतिदेय
प्रतिलाभ की मात्रा	नहीं	हाँ
उपवाद सम्भालना	चेक किए गए अपवादों को फेंका नहीं जा सकता	चेक किए गए अपवाद उत्पन्न कर सकता है
पैकेज	java.lang	java.util.concurrent

उदाहरण:

Callable<Integer> task = () -> 42;
Future<Integer> result = executor.submit(task);
System.out.println(result.get());

उदाहरण: Callable जब आपको आवश्यकता हो तो इसे प्राथमिकता दी जाती है परिणाम or अपवाद प्रसार.

---

27) प्रोड्यूसर-कंज्यूमर परिदृश्यों में ब्लॉकिंगक्यू किस प्रकार सहायता करता है?

BlockingQueue थ्रेड-सुरक्षित प्रदान करता है अवरोधक संचालन तत्वों को जोड़ने और हटाने के लिए, उत्पादक-उपभोक्ता मॉडल को सरल बनाना।

उदाहरण:

BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
new Thread(() -> queue.put(1)).start();   // Producer
new Thread(() -> System.out.println(queue.take())).start(); // Consumer

लाभ:

• स्पष्ट को हटाता है wait() और notify().
• परिबद्ध दोनों का समर्थन करता है (ArrayBlockingQueue) और असीमित (LinkedBlockingQueue) कार्यान्वयन।

---

28) थ्रेड स्टार्वेशन और लाइवलॉक के कुछ सामान्य कारण क्या हैं?

थ्रेड की कमी:

ऐसा तब होता है जब कम प्राथमिकता वाले थ्रेड्स को कभी भी सीपीयू समय नहीं मिलता क्योंकि उच्च प्राथमिकता वाले थ्रेड्स हावी रहते हैं।

लाइवलॉक:

यह तब होता है जब थ्रेड सक्रिय रहते हैं लेकिन आगे नहीं बढ़ पाते क्योंकि वे लगातार एक-दूसरे की प्रतिक्रिया में अपनी स्थिति बदलते रहते हैं (जैसे दो लोग कदम बढ़ाते हैं)।ping गलियारे में बार-बार किनारे हटकर)।

रोकथाम तकनीकें:

• अत्यधिक ताला लगाने से बचें।
• उचित ताले का प्रयोग करें (new ReentrantLock(true)).
• व्यस्त प्रतीक्षा लूप से बचें।
• थ्रेड शेड्यूलिंग का सही ढंग से उपयोग करें।

---

29) आप मल्टीथ्रेडेड के प्रदर्शन को कैसे बेहतर बना सकते हैं? Java अनुप्रयोग?

प्रमुख रणनीतियाँ:

1. उपयोग धागा पूल बार-बार नए थ्रेड बनाने के बजाय।
2. सिंक्रोनाइज़ेशन के दायरे को कम से कम करें (केवल आवश्यक चीज़ों को ही लॉक करें)।
3. पसंद करते हैं समवर्ती डेटा संरचनाएँ.
4. उपयोग अपरिवर्तनीय वस्तुओं जहां संभव।
5. थ्रेड-लोकल डेटा को अलग करके गलत शेयरिंग से बचें।
6. सीपीयू कोर के अनुसार थ्रेड्स की संख्या को समायोजित करें।
7. उपयोग अतुल्यकालिक इनपुट/आउटपुट कार्यों को अवरुद्ध करने के लिए।

उदाहरण: उपयोग ForkJoinPool or CompletableFuture सीपीयू के अधिकतम उपयोग के लिए समानांतर कार्यों के लिए।

---

30) आपने जिस वास्तविक मल्टीथ्रेडिंग परिदृश्य को संभाला है, उसका वर्णन करें। Java.

परिदृश्य उदाहरण:

भुगतान प्रसंस्करण प्रणाली में, एकरूपता और अखंडता सुनिश्चित करते हुए कई लेनदेन को एक साथ संसाधित किया जाना चाहिए।

कार्यान्वयन चरण:

1. प्रयुक्त निष्पादनकर्ता सेवा वर्कर थ्रेड्स को प्रबंधित करने के लिए।
2. लागू समवर्ती हैशमैप लेनदेन की स्थिति बनाए रखने के लिए।
3. कार्यान्वित रीएंट्रेंटलॉक खाता स्तर पर लॉक करने के लिए।
4. प्रयुक्त काउंटडाउनलैच बैच सिंक्रोनाइज़ेशन के लिए।
5. जब जोड़ा गया पूर्ण करने योग्य भविष्य अतुल्यकालिक प्रतिक्रिया प्रबंधन के लिए।

परिणाम: थ्रूपुट में 35% की वृद्धि हुई और औसत लेनदेन विलंबता में 40% की कमी आई।

---

31) वर्चुअल थ्रेड्स क्या हैं? Javaऔर ये पारंपरिक धागों से किस प्रकार भिन्न हैं?

वर्चुअल थ्रेड्स (में पेश किया गया Java 21ये हल्के थ्रेड होते हैं जिन्हें ऑपरेटिंग सिस्टम के बजाय JVM द्वारा प्रबंधित किया जाता है। ये समवर्ती कार्यों के ओवरहेड को काफी कम कर देते हैं, जिससे हजारों (या लाखों) समवर्ती कार्य संभव हो पाते हैं।

Feature	प्लेटफ़ॉर्म थ्रेड्स	वर्चुअल थ्रेड्स
के द्वारा प्रबंधित	OS	JVM
निर्माण लागत	हाई	बहुत कम
समवर्ती स्तर	सीमित (~हजारों)	विशाल (~लाखों)
निर्धारण	ओएस-स्तर	जेवीएम सहकारी
उदाहरण	सीपीयू-बाध्य कार्य	इनपुट/आउटपुट-बाउंड या उच्च-समवर्तीता वाले कार्य

उदाहरण:

Thread.startVirtualThread(() -> System.out.println("Virtual thread running"));

मुख्य लाभ:

वर्चुअल थ्रेड सिस्टम संसाधनों को अवरुद्ध किए बिना बड़े पैमाने पर एक साथ निष्पादन की अनुमति देते हैं।

---

32) संरचित समवर्तीता क्या है? Java? यह महत्वपूर्ण क्यों है?

संरचित समवर्तीता (पूर्वावलोकन में) Java 21) एकाधिक समवर्ती कार्यों को एक के रूप में मानकर मल्टीथ्रेडेड प्रोग्रामिंग को सरल बनाता है एकल संरचित इकाईयह सुनिश्चित करता है कि कार्यों को एक साथ शुरू किया जाए, प्रबंधित किया जाए और समाप्त किया जाए, जिससे विश्वसनीयता और पठनीयता में सुधार होता है।

उदाहरण:

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> user = scope.fork(() -> findUser());
    Future<Integer> order = scope.fork(() -> fetchOrderCount());
    scope.join();  
    scope.throwIfFailed();
    System.out.println(user.resultNow() + " has " + order.resultNow() + " orders.");
}

लाभ:

• रद्द करने और त्रुटि प्रसार को आसान बनाना।
• कोई अनाथ थ्रेड नहीं।
• अनुमानित कार्य जीवनचक्र।

---

33) रिएक्टिव स्ट्रीम क्या हैं? Javaऔर वे समवर्तीता को कैसे बेहतर बनाते हैं?

प्रतिक्रियाशील धाराएँ उपलब्ध करें गैर अवरुद्ध, अतुल्यकालिक डेटा स्ट्रीम को संभालने के लिए बैकप्रेशर-आधारित मॉडल।

वे इसके लिए डिज़ाइन किए गए हैं उच्च throughput, घटना संचालित सिस्टम.

कोर इंटरफेस:

• Publisher – डेटा उत्पन्न करता है।
• Subscriber – डेटा का उपभोग करता है।
• Subscription – यह बैकप्रेशर को नियंत्रित करता है।
• Processor – यह दोनों तरह से कार्य करता है।

उदाहरण:

Flow.Publisher<Integer> publisher = subscriber -> subscriber.onNext(42);

बक्सों का इस्तेमाल करें:

रिएक्टिव स्ट्रीम्स इसके लिए मूलभूत हैं प्रोजेक्ट रिएक्टर, RxJava, तथा स्प्रिंग वेबFluxजिससे स्केलेबल एपीआई और माइक्रोसेवाएं सक्षम हो पाती हैं।

---

34) आप थ्रेड व्यवधान को ठीक से कैसे संभालते हैं? Java?

थ्रेड इंटरप्ट की मदद से किसी थ्रेड को यह संकेत दिया जा सकता है कि उसे रुक जाना चाहिए या अपने व्यवहार में बदलाव करना चाहिए।

सर्वोत्तम प्रथाएं:

1. हमेशा जांचें Thread.interrupted() लूप में।
2. बाहर निकलने से पहले संसाधनों को साफ कर लें।
3. दबाएँ नहीं InterruptedException.

उदाहरण:

while (!Thread.currentThread().isInterrupted()) {
    try { Thread.sleep(1000); } 
    catch (InterruptedException e) {
        Thread.currentThread().interrupt(); // restore flag
        break;
    }
}

सामान्य गलती:

कैच करने के बाद इंटरप्ट स्थिति को पुनर्स्थापित करने में विफलता InterruptedException.

---

35) समानांतरता और समवर्तीता के बीच अंतर स्पष्ट कीजिए।

यद्यपि प्रायः इनका प्रयोग एक दूसरे के स्थान पर किया जाता है, समानता और संगामिति विभिन्न निष्पादन मॉडलों का संदर्भ लें।

संकल्पना	परिभाषा	उदाहरण
संगामिति	कार्यों के निष्पादन को इंटरलीव करके कई कार्यों का प्रबंधन करना।	एक साथ 1000 क्लाइंट अनुरोधों को संभालना
समानता	एक साथ कई कार्यों को निष्पादित करना	कई सीपीयू कोर में गणनाएँ चलाना

सादृश्य: समवर्तीता है about structure (कई चीजों से निपटना), जबकि समानांतरता है about execution (एक साथ कई काम करना)।

---

36) सामान्य थ्रेड प्रोफाइलिंग उपकरण और तकनीकें क्या हैं? Java?

डेडलॉक, ब्लॉकिंग और सीपीयू हॉगिंग जैसी थ्रेड समस्याओं का निदान करने के लिए, आप विभिन्न तरीकों का उपयोग कर सकते हैं। प्रोफाइलिंग उपकरण.

उपकरण	उद्देश्य
जेस्टैक	थ्रेड डंप कैप्चर करता है
जेकंसोल / VisualVM	रीयल-टाइम थ्रेड मॉनिटरिंग
Java फ्लाइट रिकॉर्डर (जेएफआर)	उत्पादन के लिए कम लागत वाली प्रोफाइलिंग
मिशन नियंत्रण (जेएमसी)	जेएफआर रिकॉर्डिंग को प्रदर्शित करता है
अतुल्यकालिक-प्रोफाइलर	सीपीयू और आवंटन प्रोफाइलिंग
थ्रेडएमएक्सबीन	प्रोग्रामेटिक थ्रेड निरीक्षण

उदाहरण (थ्रेडएमएक्सबीन):

ThreadMXBean bean = ManagementFactory.getThreadMXBean();
System.out.println(bean.getThreadCount());

---

37) मल्टीथ्रेडेड में सामान्य प्रदर्शन संबंधी बाधाएँ क्या हैं? Java अनुप्रयोग?

सामान्य अड़चनें:

1. अत्यधिक लॉक विवाद: एक ही लॉक के लिए कई थ्रेड्स प्रतिस्पर्धा कर रहे हैं।
2. गलत साझाकरण: थ्रेड्स उन वेरिएबल्स को संशोधित करते हैं जो एक ही सीपीयू कैश लाइन को साझा करते हैं।
3. संदर्भ स्विचिंग ओवरहेड: बहुत अधिक थ्रेड्स होने से शेड्यूलिंग में देरी होती है।
4. अनुचित Syncआधुनिकीकरण: इससे अवरोध या गतिरोध उत्पन्न हो सकता है।
5. स्मृति संबंधी बाधाएँ: अस्थिर चरों का अत्यधिक उपयोग।

अनुकूलन:

• बारीक दानेदार या लॉक-मुक्त संरचनाओं का उपयोग करें।
• थ्रेड निर्माण को न्यूनतम करें।
• पृथक डेटा के लिए थ्रेड-लोकल स्टोरेज का उपयोग करें।
• ऑप्टिमाइज़ करने से पहले प्रोफ़ाइल बनाएं।

---

38) लॉक-फ्री, वेट-फ्री और ऑब्स्ट्रक्शन-फ्री एल्गोरिदम में क्या अंतर है?

प्रकार	परिभाषा	गारंटी
ताला मुक्त	कम से कम एक पहलू में तो प्रगति हो रही है।	प्रणाली-व्यापी प्रगति।
प्रतीक्षा मुक्त	प्रत्येक थ्रेड सीमित चरणों में आगे बढ़ता है।	सबसे मजबूत गारंटी।
बाधा से मुक्त	विवाद के अभाव में प्रगति।	सबसे कमजोर गारंटी।

उदाहरण: AtomicInteger संचालन हैं ताला मुक्तजबकि ब्लॉकिंग क्यू लॉक का उपयोग करते हैं।

उदाहरण: लॉक-मुक्त एल्गोरिदम इसके लिए आदर्श हैं उच्च-प्रदर्शन समवर्ती डेटा संरचनाएँ जैसे कि डिसरप्टर या कॉन्करेंटलिंक्डक्यू।

---

१) कैसे करता है Java क्या ForkJoinPool अंदरूनी तौर पर काम करता है?

ForkJoinPool के लिए बनाया गया है फूट डालो और राज करो कार्य और उपयोग कामचोरी थ्रेड्स के बीच लोड को संतुलित करने के लिए।

तंत्र:

• प्रत्येक वर्कर थ्रेड अपनी स्वयं की डेक्यू (डबल-एंडेड क्यू) बनाए रखता है।
• निष्क्रिय रहने पर, यह अन्य थ्रेड्स के डेक्यू से कार्य चुरा लेता है।
• यह टकराव को कम करता है और उत्पादन क्षमता को बढ़ाता है।

उदाहरण:

ForkJoinPool pool = new ForkJoinPool();
pool.submit(() -> IntStream.range(0, 100).parallel().forEach(System.out::println));

लाभ: पुनरावर्ती और समानांतर रूप से किए जा सकने वाले कार्यभारों (सॉर्टिंग, गणना, डेटा रूपांतरण) के लिए आदर्श।

---

40) आप एक अत्यधिक समवर्ती प्रणाली को कैसे डिज़ाइन करेंगे? Java क्या यह सिस्टम प्रति सेकंड लाखों अनुरोधों को संभाल सकता है?

उदाहरण Archiटेक्चर:

लचीलेपन और स्केलेबिलिटी के साथ व्यापक समवर्तीता प्राप्त करने के लिए:

1. वर्चुअल थ्रेड्स का उपयोग करें हल्के अनुरोधों को संभालने के लिए।
2. रिएक्टिव स्ट्रीम्स का उपयोग करें अतुल्यकालिक इनपुट/आउटपुट प्रोसेसिंग के लिए।
3. संरचित समवर्तीता को अपनाएं प्रबंधनीय समानांतर कार्यों के लिए।
4. बार-बार उपयोग किए जाने वाले डेटा को कैश करें का उपयोग ConcurrentHashMap or Caffeine.
5. थ्रेड-सेफ कतारों का उपयोग करें (Disruptor, BlockingQueue) इवेंट पास करने के लिए।
6. निगरानी करें और ट्यून करें जेएफआर + जेएमसी के साथ।
7. पूर्ण करने योग्य भविष्य का लाभ उठाएं अतुल्यकालिक वर्कफ़्लो के लिए।

रिजल्ट: यह सिस्टम न्यूनतम अवरोधन और अनुकूलित संसाधन उपयोग के साथ लाखों समवर्ती कनेक्शन प्राप्त करता है।

---

🔍 शीर्ष Java वास्तविक दुनिया के परिदृश्यों और रणनीतिक प्रतिक्रियाओं के साथ मल्टीथ्रेडिंग से संबंधित साक्षात्कार प्रश्न

नीचे दस व्यावहारिक और आमतौर पर पूछे जाने वाले प्रश्न दिए गए हैं। Java multithreading साक्षात्कार के प्रश्न, साक्षात्कारकर्ता की अपेक्षाएं और संभावित उत्तरों के उदाहरण।

1) प्रोसेस और थ्रेड में क्या अंतर है? Java?

उम्मीदवार से अपेक्षित: ऑपरेटिंग सिस्टम और जेवीएम के मूलभूत सिद्धांतों, मेमोरी के उपयोग और निष्पादन प्रवाह की समझ प्रदर्शित करें।

उदाहरण उत्तर: एक प्रोसेस एक स्वतंत्र प्रोग्राम होता है जिसका अपना मेमोरी स्पेस होता है, जबकि एक थ्रेड एक्जीक्यूशन की एक छोटी इकाई होती है जो प्रोसेस के भीतर चलती है। थ्रेड्स प्रोसेस की समान मेमोरी और संसाधनों को साझा करते हैं, जिससे कॉन्टेक्स्ट स्विचिंग तेज़ होती है और परफॉर्मेंस बेहतर होता है। यह साझा मेमोरी मॉडल कुशल संचार की अनुमति देता है, लेकिन रेस कंडीशन से बचने के लिए सावधानीपूर्वक सिंक्रोनाइज़ेशन की भी आवश्यकता होती है।

---

2) क्या आप सिंक्रोनाइज्ड कीवर्ड का उद्देश्य और इसका उपयोग कब किया जाना चाहिए, समझा सकते हैं?

उम्मीदवार से अपेक्षित: समवर्ती नियंत्रण, आंतरिक लॉक और थ्रेड सुरक्षा की व्याख्या करने की क्षमता।

उदाहरण उत्तर: RSI synchronized यह कीवर्ड सुनिश्चित करता है कि एक समय में केवल एक ही थ्रेड कोड के क्रिटिकल सेक्शन तक पहुंच सके। इसका उपयोग तब किया जाता है जब कई थ्रेड्स द्वारा साझा किए गए परिवर्तनीय डेटा तक पहुंचा जा रहा हो। ऑब्जेक्ट के मॉनिटर लॉक पर सिंक्रोनाइज़ करके, डेवलपर्स रेस कंडीशन को रोकते हैं और डेटा की अखंडता बनाए रखते हैं।

---

3) आपके सामने आई किसी चुनौतीपूर्ण मल्टीथ्रेडिंग समस्या का वर्णन करें और बताएं कि आपने उसे कैसे हल किया।

उम्मीदवार से अपेक्षित: समस्या समाधान, डिबगिंग कौशल और वास्तविक दुनिया में समवर्तीता का अनुभव।

उदाहरण उत्तर: अपनी पिछली भूमिका में, मुझे दो थ्रेड्स द्वारा लॉक के लिए उल्टे क्रम में प्रतीक्षा करने के कारण गतिरोध की समस्या का सामना करना पड़ा। मैंने कोड को पुनर्गठित करके और लॉक प्राप्त करने के एक सुसंगत क्रम को लागू करके इसे हल किया। इससे यह सुनिश्चित हुआ कि थ्रेड्स को लॉक एक ही क्रम में प्राप्त हों, जिससे गतिरोध का खतरा समाप्त हो गया।

---

१) कैसे करता है Java क्या मेमोरी मॉडल मल्टीथ्रेडेड अनुप्रयोगों में दृश्यता और क्रमबद्धता सुनिश्चित करता है?

उम्मीदवार से अपेक्षित: जेएमएम अवधारणाओं का ज्ञान, volatile, पहले घटित होने वाले संबंध।

उदाहरण उत्तर: RSI Java मेमोरी मॉडल यह परिभाषित करता है कि एक थ्रेड द्वारा किए गए परिवर्तन कब और कैसे दूसरों को दिखाई देंगे। यह 'हैपन्स-बिफोर' संबंधों का उपयोग करता है जो क्रमबद्धता की गारंटी देते हैं। volatile यह सुनिश्चित करता है कि लिखे गए डेटा को मुख्य मेमोरी में फ्लश कर दिया जाए और पढ़े गए डेटा हमेशा नवीनतम मान को ही प्राप्त करें। Syncकालानुक्रमिक संरचनाएं 'पहले घटित होने वाली घटनाओं' की सीमाएं भी बनाती हैं।

---

5) wait(), notify() और notifyAll() में क्या अंतर है?

उम्मीदवार से अपेक्षित: इंटर-थ्रेड संचार और ऑब्जेक्ट मॉनिटर की कार्यप्रणाली की समझ।

उदाहरण उत्तर: RSI wait() यह विधि किसी थ्रेड को मॉनिटर लॉक छोड़ने और सूचना मिलने तक निष्पादन को निलंबित करने का कारण बनती है। notify() यह विधि एक प्रतीक्षारत थ्रेड को जगाती है, जबकि notifyAll() यह विधि एक ही मॉनिटर पर प्रतीक्षा कर रहे सभी थ्रेड्स को जगा देती है। ये विधियाँ साझा स्थिति पर निर्भर थ्रेड्स के बीच समन्वय को सुगम बनाती हैं।

---

6) एक ऐसे समय का वर्णन करें जब आपको मल्टीथ्रेडेड एप्लिकेशन के प्रदर्शन को अनुकूलित करना पड़ा हो।

उम्मीदवार से अपेक्षित: समवर्ती कार्यक्षमता को मापने, निदान करने और बेहतर बनाने की क्षमता।

उदाहरण उत्तर: पिछली नौकरी में, मैंने एक मल्टीथ्रेडेड डेटा प्रोसेसिंग सिस्टम को ऑप्टिमाइज़ किया था जिसमें थ्रूपुट संबंधी समस्याएँ आ रही थीं। मैंने एक साझा संसाधन पर अत्यधिक लॉक टकराव का पता लगाया। मैंने सिंक्रोनाइज़्ड ब्लॉक को बदलकर इस समस्या का समाधान किया। ConcurrentHashMapजिससे टकराव कम हुआ और समानांतर प्रसंस्करण दक्षता में उल्लेखनीय सुधार हुआ।

---

7) आप ऐसी स्थिति को कैसे संभालेंगे जहां कई थ्रेड्स को एक साझा डेटा संरचना को सुरक्षित रूप से अपडेट करने की आवश्यकता हो?

उम्मीदवार से अपेक्षित: समवर्ती संग्रह, लॉक और डिजाइन रणनीतियों का ज्ञान।

उदाहरण उत्तर: यदि कई थ्रेड्स को साझा डेटा संरचना को अपडेट करने की आवश्यकता है, तो मैं थ्रेड-सेफ कलेक्शन का चयन करूंगा। java.util.concurrentइस तरह के रूप में, ConcurrentLinkedQueue or ConcurrentHashMapवैकल्पिक रूप से, मैं स्पष्ट लॉकिंग का उपयोग करूंगा। ReentrantLock यदि अधिक विस्तृत नियंत्रण की आवश्यकता हो, तो यह दृष्टिकोण डेटा की स्थिरता सुनिश्चित करता है और समवर्ती त्रुटियों को रोकता है।

---

8) एक्ज़ीक्यूटर सर्विस की भूमिका क्या है, और मैन्युअल रूप से थ्रेड बनाने की तुलना में इसे क्यों प्राथमिकता दी जाती है?

उम्मीदवार से अपेक्षित: थ्रेड पूलिंग, लाइफसाइकिल मैनेजमेंट और स्केलेबिलिटी की समझ।

उदाहरण उत्तर: ExecutorService यह वर्कर थ्रेड्स के एक पूल का प्रबंधन करता है और कार्यों को कुशलतापूर्वक शेड्यूल करता है। इसे प्राथमिकता दी जाती है क्योंकि यह थ्रेड्स के पुन: उपयोग से ओवरहेड को कम करता है, स्केलेबिलिटी में सुधार करता है और लाइफसाइकिल प्रबंधन को सरल बनाता है। यह थ्रेड्स को बंद करने और कार्य पूर्णता को संभालने के लिए सुव्यवस्थित तंत्र भी प्रदान करता है।

---

9) मुझे एक ऐसी स्थिति के बारे में बताएं जहां आपको रेस कंडीशन की समस्या का निवारण करना पड़ा हो। आपने इसे कैसे पहचाना और ठीक किया?

उम्मीदवार से अपेक्षित: निदान तकनीकें, लॉगिंग, डिबगिंग उपकरण।

उदाहरण उत्तर: अपनी पिछली नौकरी में, लोड के तहत असंगत आउटपुट देखने के बाद मैंने वित्तीय गणना मॉड्यूल में एक रेस कंडीशन की पहचान की। मैंने स्ट्रेस टेस्टिंग और बेहतर लॉगिंग का उपयोग करके इस समस्या को दोबारा उत्पन्न किया। track थ्रेड एक्सेस पैटर्न। मैंने साझा गणना ब्लॉक के आसपास उचित सिंक्रोनाइज़ेशन लागू करके इसे ठीक कर दिया, जिससे असंगत व्यवहार समाप्त हो गया।

---

10) जब कार्यों की प्राथमिकताएं और निष्पादन समय अलग-अलग हों तो आप मल्टीथ्रेडिंग समाधान कैसे डिजाइन करते हैं?

उम्मीदवार से अपेक्षित: समवर्ती समाधानों की संरचना करने और उपयुक्त एपीआई चुनने की क्षमता।

उदाहरण उत्तर: इस परिदृश्य में, मैं प्राथमिकता-आधारित कार्य कतार का उपयोग करूंगा। ThreadPoolExecutor और एक कस्टम Comparator उच्च प्राथमिकता वाले कार्यों को पहले निष्पादित करने के लिए। अलग-अलग अवधि वाले कार्यों के लिए, मैं CPU कोर के आधार पर थ्रेड पूल का आकार निर्धारित करूँगा और कतार के आकार और अस्वीकृति रणनीतियों को समायोजित करने के लिए मॉनिटरिंग टूल का उपयोग करूँगा।