S12L13 - जावा मल्टीथ्रेडिंग में वेट और नोटिफाई जारी

html

Java Multithreading में Wait और Notify में महारत हासिल करना
विषय सूची

परिचय ………………………………………………………… 1
Java में बहु-थ्रेडिंग को समझना ……… 3
संकुलन का महत्व ………… 5
Wait और Notify विधियों का अन्वेषण ………….. 7

Wait विधि
Notify और NotifyAll विधियाँ


प्रायोगिक कार्यान्वयन: बैंक खाता सिमुलेशन ………… 11

परियोजना अवलोकन
कोड विश्लेषण
परियोजना को निष्पादित करना


सामान्य गलतियाँ और सर्वोत्तम प्रथाएँ ………. 17
निष्कर्ष ………………………………………………………….. 21


परिचय
Java Multithreading में Wait और Notify में महारत हासिल करने में आपका स्वागत है, जो Java में संकुलन तंत्रों को समझने और प्रभावी ढंग से लागू करने के लिए आपका व्यापक मार्गदर्शिका है। समवर्ती प्रोग्रामिंग के क्षेत्र में, यह प्रबंधित करना कि कैसे कई थ्रेड्स इंटरैक्ट करते हैं, मजबूत और कुशल अनुप्रयोगों के निर्माण के लिए महत्वपूर्ण है। यह ईबुक wait और notify विधियों की बारीकियों में गोता लगाता है, स्पष्ट व्याख्याएं, व्यावहारिक उदाहरण और सर्वोत्तम प्रथाएं प्रदान करता है ताकि आपकी बहु-थ्रेडिंग क्षमताओं को बढ़ाया जा सके।
मुख्य विशेषताएँ:

Java बहु-थ्रेडिंग के मूल सिद्धांतों को समझना।
संकुलन और इसके महत्व को समझना।
wait, notify, और notifyAll विधियों में गहराई से डुबकी लगाना।
एक वास्तविक जीवन की बैंक खाता सिमुलेशन परियोजना का अन्वेषण।
सामान्य संकुलन गलतियों से बचना सीखें।


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

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

Java में थ्रेड्स
Java Thread क्लास और Runnable इंटरफेस प्रदान करता है ताकि थ्रेड्स को बनाया और प्रबंधित किया जा सके।




		
		
			
			
Java
			
			// Thread क्लास का विस्तार करना
class MyThread extends Thread {
    public void run() {
        // करने के लिए कार्य
    }
}

// Runnable इंटरफेस को लागू करना
class MyRunnable implements Runnable {
    public void run() {
        // करने के लिए कार्य
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						// Thread क्लास का विस्तार करना
class MyThread extends Thread {
    public void run() {
        // करने के लिए कार्य
    }
}
 
// Runnable इंटरफेस को लागू करना
class MyRunnable implements Runnable {
    public void run() {
        // करने के लिए कार्य
    }
}
					
				
			
		



संकुलन का महत्व
संकुलन क्या है?
संकुलन वह प्रक्रिया है जिसमें कई थ्रेड्स के साझा संसाधनों तक पहुँच को नियंत्रित किया जाता है। उचित संकुलन के बिना, थ्रेड्स एक-दूसरे में हस्तक्षेप कर सकते हैं, जिससे डेटा स्थितियाँ असंगत और अप्रत्याशित व्यवहार उत्पन्न हो सकते हैं।
क्यों संकुलन करना चाहिए?

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

Java में संकुलन तंत्र

संकुलित विधियाँ: पूरी विधि को लॉक करती हैं।
संकुलित ब्लॉक: कोड के एक विशिष्ट ब्लॉक को लॉक करती हैं।
Wait और Notify विधियाँ: थ्रेड्स के बीच संचार की सुविधा प्रदान करती हैं।


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




		
		
			
			
Java
			
			synchronized (object) {
    while (condition) {
        object.wait();
    }
    // सूचित होने पर आगे बढ़ें
}
			
				
					
				
					1
2
3
4
5
6
				
						synchronized (object) {
    while (condition) {
        object.wait();
    }
    // सूचित होने पर आगे बढ़ें
}
					
				
			
		


ओवरलोडेड संस्करण:

wait(long millis): निर्दिष्ट मिलीसेकंड के लिए प्रतीक्षा करता है।
wait(long millis, int nanos): निर्दिष्ट मिलीसेकंड और नैनोसेकंड के लिए प्रतीक्षा करता है।

Notify और NotifyAll विधियाँ

Notify (notify()): ऑब्जेक्ट के मॉनिटर पर प्रतीक्षा कर रहे एक अकेले थ्रेड को जगाता है।
Notify All (notifyAll()): ऑब्जेक्ट के मॉनिटर पर प्रतीक्षा कर रहे सभी थ्रेड्स को जगाता है।

उपयोग:




		
		
			
			
Java
			
			synchronized (object) {
    // शर्त/स्थिति में बदलाव करें
    object.notify(); // या object.notifyAll();
}
			
				
					
				
					1
2
3
4
				
						synchronized (object) {
    // शर्त/स्थिति में बदलाव करें
    object.notify(); // या object.notifyAll();
}
					
				
			
		


Wait और Notify के बीच मुख्य अंतर


विशेषता
wait()
notify()


उद्देश्य
वर्तमान थ्रेड को प्रतीक्षा में डालता है
प्रतीक्षा कर रहे थ्रेड को जगाता है


लॉक रिलीज
हाँ
संकुलित ब्लॉक की आवश्यकता होती है


सूचित किए गए थ्रेड्स की संख्या
कोई नहीं (सिर्फ प्रतीक्षा)
एकल थ्रेड



प्रायोगिक कार्यान्वयन: बैंक खाता सिमुलेशन
परियोजना अवलोकन
wait और notify के प्रायोगिक अनुप्रयोग को स्पष्ट करने के लिए, हम एक सरल बैंक खाता प्रणाली का सिमुलेशन करेंगे जहाँ कई थ्रेड्स समवर्ती रूप से निकासी और जमा संचालन करते हैं। यह उदाहरण डेटा की अखंडता बनाए रखने के लिए थ्रेड संकुलन को प्रबंधित करने का तरीका दर्शाता है।
परियोजना संरचना:




		
		
			
			
Java
			
			BankAccountSimulation.zip
├── pom.xml
├── src
│   ├── main
│   │   └── java
│   │       └── org/studyeasy
│   │           └── Main.java
│   └── test
│       └── java
│           └── org/studyeasy
│               └── MainTest.java
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						BankAccountSimulation.zip
├── pom.xml
├── src
│   ├── main
│   │   └── java
│   │       └── org/studyeasy
│   │           └── Main.java
│   └── test
│       └── java
│           └── org/studyeasy
│               └── MainTest.java
					
				
			
		


कोड विश्लेषण
Main.java




		
		
			
			
Java
			
			package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        
        Thread withdrawalThread = new Thread(new Withdrawal(account, 1000));
        Thread depositThread = new Thread(new Deposit(account, 2000));
        
        withdrawalThread.start();
        depositThread.start();
    }
}

class BankAccount {
    private int balance = 1000;

    // संकुलित निकासी विधि
    public synchronized void withdraw(int amount) {
        System.out.println("Attempting to withdraw $" + amount);
        if (balance < amount) {
            System.out.println("Insufficient funds. Waiting for deposit...");
            try {
                wait(3000); // जमा के लिए प्रतीक्षा करें
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        balance -= amount;
        System.out.println("Withdrawal of $" + amount + " completed. Current Balance: $" + balance);
    }

    // संकुलित जमा विधि
    public synchronized void deposit(int amount) {
        System.out.println("Depositing $" + amount);
        balance += amount;
        System.out.println("Deposit of $" + amount + " completed. Current Balance: $" + balance);
        notify(); // प्रतीक्षा कर रहे थ्रेड्स को सूचित करें
    }
}

class Withdrawal implements Runnable {
    private BankAccount account;
    private int amount;

    public Withdrawal(BankAccount account, int amount) {
        this.account = account;
        this.amount = amount;
    }

    public void run() {
        account.withdraw(amount);
    }
}

class Deposit implements Runnable {
    private BankAccount account;
    private int amount;

    public Deposit(BankAccount account, int amount) {
        this.account = account;
        this.amount = amount;
    }

    public void run() {
        try {
            Thread.sleep(2000); // प्रोसेसिंग समय की नकल करना
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.deposit(amount);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
				
						package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        
        Thread withdrawalThread = new Thread(new Withdrawal(account, 1000));
        Thread depositThread = new Thread(new Deposit(account, 2000));
        
        withdrawalThread.start();
        depositThread.start();
    }
}
 
class BankAccount {
    private int balance = 1000;
 
    // संकुलित निकासी विधि
    public synchronized void withdraw(int amount) {
        System.out.println("Attempting to withdraw $" + amount);
        if (balance < amount) {
            System.out.println("Insufficient funds. Waiting for deposit...");
            try {
                wait(3000); // जमा के लिए प्रतीक्षा करें
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        balance -= amount;
        System.out.println("Withdrawal of $" + amount + " completed. Current Balance: $" + balance);
    }
 
    // संकुलित जमा विधि
    public synchronized void deposit(int amount) {
        System.out.println("Depositing $" + amount);
        balance += amount;
        System.out.println("Deposit of $" + amount + " completed. Current Balance: $" + balance);
        notify(); // प्रतीक्षा कर रहे थ्रेड्स को सूचित करें
    }
}
 
class Withdrawal implements Runnable {
    private BankAccount account;
    private int amount;
 
    public Withdrawal(BankAccount account, int amount) {
        this.account = account;
        this.amount = amount;
    }
 
    public void run() {
        account.withdraw(amount);
    }
}
 
class Deposit implements Runnable {
    private BankAccount account;
    private int amount;
 
    public Deposit(BankAccount account, int amount) {
        this.account = account;
        this.amount = amount;
    }
 
    public void run() {
        try {
            Thread.sleep(2000); // प्रोसेसिंग समय की नकल करना
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.deposit(amount);
    }
}
					
				
			
		


कोड व्याख्या

BankAccount क्लास:

Balance: खाते में वर्तमान शेष राशि का प्रतिनिधित्व करता है।
withdraw विधि:

संकुलित है ताकि समवर्ती पहुँच को रोका जा सके।
चेक करता है कि शेष राशि पर्याप्त है या नहीं। यदि नहीं, तो यह एक जमा के लिए प्रतीक्षा करता है।
wait(3000) का उपयोग 3 सेकंड तक प्रतीक्षा करने के लिए किया जाता है।


deposit विधि:

थ्रेड सुरक्षा सुनिश्चित करने के लिए संकुलित है।
शेष राशि में जमा राशि जोड़ता है।
notify() को बुलाता है ताकि प्रतीक्षा कर रहे निकासी थ्रेड्स को जगाया जा सके।




Withdrawal क्लास:

Runnable को लागू करता है ताकि एक अलग थ्रेड में निकासी कर सके।
BankAccount की withdraw विधि को बुलाता है।


Deposit क्लास:

Runnable को लागू करता है ताकि एक अलग थ्रेड में जमा कर सके।
deposit विधि को बुलाने से पहले 2 सेकंड के लिए सोता है ताकि प्रोसेसिंग समय की नकल हो सके।


Main क्लास:

Withdrawal और Deposit के उदाहरण बनाता है।
दोनों थ्रेड्स को शुरू करता है, जिससे समवर्ती संचालन शुरू होते हैं।



परियोजना को निष्पादित करना
Main क्लास को चलाने पर, निम्नलिखित घटनाओं की श्रृंखला घटित होती है:

Withdrawal थ्रेड:

$1000 निकालने की कोशिश करता है।
यदि शेष राशि अपर्याप्त है, तो जमा के लिए प्रतीक्षा करता है।


Deposit थ्रेड:

प्रोसेसिंग में देरी को सिमुलेट करने के लिए 2 सेकंड तक सोता है।
$2000 जमा करता है।
प्रतीक्षा कर रहे withdrawal थ्रेड को सूचित करता है।


अंतिम आउटपुट:

जमा के बाद निकासी पूरी होती है, जिससे शेष राशि को अपडेट किया जाता है।



अपेक्षित आउटपुट:




		
		
			
			
Java
			
			Attempting to withdraw $1000
Withdrawal of $1000 completed. Current Balance: $0
Depositing $2000
Deposit of $2000 completed. Current Balance: $2000
			
				
					
				
					1
2
3
4
				
						Attempting to withdraw $1000
Withdrawal of $1000 completed. Current Balance: $0
Depositing $2000
Deposit of $2000 completed. Current Balance: $2000
					
				
			
		



सामान्य गलतियाँ और सर्वोत्तम प्रथाएँ
सामान्य गलतियाँ

संकुलित ब्लॉकों का उपयोग नहीं करना:

साझा संसाधनों तक पहुँच को संकुलित नहीं करने से रेस कंडीशन्स और असंगत स्थितियाँ उत्पन्न हो सकती हैं।


Wait और Notify का गलत उपयोग:

संकुलित संदर्भ के भीतर wait या notify को नहीं बुलाने से IllegalMonitorStateException उत्पन्न होता है।


Deadlocks:

जब दो या अधिक थ्रेड्स अनिश्चित काल तक एक-दूसरे के लॉक्स रिलीज होने का इंतजार करते हैं।


notify का उपयोग notifyAll के बजाय करना:

ऐसे परिदृश्यों में जहाँ कई थ्रेड्स प्रतीक्षा कर सकते हैं, notify का उपयोग करने से कुछ थ्रेड्स ब्लॉक रह सकते हैं।



सर्वोत्तम प्रथाएँ

हमेशा साझा संसाधनों को संकुलित करें:

साझा डेटा तक पहुँच को नियंत्रित करने के लिए संकुलित विधियों या ब्लॉकों का उपयोग करें।


जब कई थ्रेड्स प्रतीक्षा कर रहे हों तो notifyAll का उपयोग करें:

सुनिश्चित करता है कि सभी प्रतीक्षा कर रहे थ्रेड्स को सूचित किया जाता है, जिससे अनिश्चितकालीन ब्लॉकिंग को रोका जा सके।


संकुलित ब्लॉकों के क्षेत्र को कम से कम रखें:

प्रदर्शन बढ़ाने के लिए संकुलन को सबसे छोटे आवश्यक कोड खंड तक सीमित करें।


InterruptedException को ठीक से संभालें:

हमेशा InterruptedException को पकड़ें और संभालें ताकि थ्रेड की प्रतिक्रियाशीलता बनी रहे।


wait का उपयोग मनमाने समय सीमाओं के साथ न करें:

टाइमआउट्स की बजाय स्थिति-आधारित प्रतीक्षाओं को प्राथमिकता दें ताकि अधिक विश्वसनीय थ्रेड समन्वय हो सके।




निष्कर्ष
wait और notify विधियों में महारत हासिल करना Java में विश्वसनीय और कुशल बहु-थ्रेडेड अनुप्रयोगों के निर्माण के लिए आवश्यक है। संकुलन तंत्रों को समझकर और सर्वोत्तम प्रथाओं को लागू करके, आप थ्रेड इंटरैक्शन्स को प्रभावी ढंग से प्रबंधित कर सकते हैं, डेटा की अखंडता और अनुकूलित प्रदर्शन सुनिश्चित करते हुए।
मुख्य बिंदु:

संकुलन: साझा संसाधनों तक पहुँच को प्रबंधित करने के लिए महत्वपूर्ण।
Wait और Notify: थ्रेड्स के बीच संचार की सुविधा प्रदान करते हैं, समन्वित निष्पादन की अनुमति देते हैं।
सर्वोत्तम प्रथाएँ: संकुलन प्रोटोकॉल का पालन करने से सामान्य थ्रेडिंग समस्याएँ जैसे डेडलॉक्स और रेस कंडीशन्स से बचा जा सकता है।

इन अवधारणाओं को अपनाएं ताकि आप Java की बहु-थ्रेडिंग क्षमताओं की पूरी शक्ति का लाभ उठा सकें, उच्च-प्रदर्शन और स्केलेबल अनुप्रयोगों को बनाने के मार्ग को प्रशस्त करते हुए।
यह लेख AI द्वारा निर्मित है।
विशेषता	wait()	notify()
उद्देश्य	वर्तमान थ्रेड को प्रतीक्षा में डालता है	प्रतीक्षा कर रहे थ्रेड को जगाता है
लॉक रिलीज	हाँ	संकुलित ब्लॉक की आवश्यकता होती है
सूचित किए गए थ्रेड्स की संख्या	कोई नहीं (सिर्फ प्रतीक्षा)	एकल थ्रेड