S12L12 - जावा मल्टीथ्रेडिंग में प्रतीक्षा और अधिसूचित करना

html


Java मल्टीथ्रेडिंग में Wait और Notify को मास्टर करना: शुरुआती के लिए एक व्यापक गाइड
सामग्री तालिका

परिचय
Java में Wait और Notify को समझना
प्रोजेक्ट सेटअप करना
Wait और Notify मैकेनिज्म को लागू करना
एप्लिकेशन चलाना
सामान्य समस्याएँ और समाधान
निष्कर्ष

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

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

फायदे और नुकसान


फायदे
नुकसान


कुशल थ्रेड कम्यूनिकेशन
यदि सही ढंग से प्रबंधित न किया जाए तो जटिल कोड हो सकता है


संसाधन प्रतिस्पर्धा को रोकता है
यदि सही ढंग से लागू न किया जाए तो डेडलॉक की संभावना


एप्लिकेशन के प्रदर्शन को बढ़ाता है
थ्रेड सिंक्रनाइज़ेशन की ठोस समझ की आवश्यकता


जब और कहाँ उपयोग करें Wait और Notify

जब: तब wait और notify का उपयोग करें जब थ्रेड्स को संसाधनों की उपलब्धता या कार्यों की पूर्णता के बारे में संवाद करने की आवश्यकता हो।
कहाँ: आमतौर पर उत्पादक-उपभोक्ता समस्याओं, बैंकिंग लेनदेन, और किसी भी स्थिति में जहां समन्वित थ्रेड निष्पादन की आवश्यकता हो, में उपयोग किया जाता है।

Java में Wait और Notify को समझना
मुख्य अवधारणाएँ और शब्दावली

Thread: प्रोसेसिंग की सबसे छोटी इकाई जिसे Java Virtual Machine (JVM) द्वारा प्रबंधित किया जा सकता है।
Synchronization: साझा संसाधनों तक कई थ्रेड्स की पहुँच को नियंत्रित करने का मैकेनिज्म।
wait(): वर्तमान थ्रेड को तब तक इंतजार करने का कारण बनता है जब तक कि कोई अन्य थ्रेड उसी ऑब्जेक्ट पर notify() या notifyAll() को नहीं बुलाता।
notify(): ऑब्जेक्ट के मॉनिटर पर इंतजार कर रहे एकल थ्रेड को जगाता है।

Wait और Notify कैसे काम करते हैं

wait():

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


notify():

जब एक थ्रेड notify() को कॉल करता है, तो यह ऑब्जेक्ट के मॉनिटर पर इंतजार कर रहे एकल थ्रेड को जगाता है।
जागे हुए थ्रेड तब तक आगे नहीं बढ़ सकता जब तक कि वर्तमान थ्रेड मॉनिटर को छोड़ नहीं देता।



प्रकाशनात्मक आरेख

आकृति 1: थ्रेड सिंक्रनाइज़ेशन में Wait और Notify मैकेनिज्म के बीच इंटरैक्शन।
प्रोजेक्ट सेटअप करना
wait और notify मैकेनिज्म को प्रदर्शित करने के लिए, हम एक सरल Java एप्लिकेशन बनाएंगे जो एक बैंकिंग परिदृश्य का अनुकरण करता है जहाँ एक थ्रेड निकासी की अनुमति से पहले जमा के लिए इंतजार करता है।
प्रोजेक्ट संरचना




		
		
			
			
Java
			
			S12L12 - Wait and Notify in Java Multithreading/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/studyeasy/
│   │           └── Main.java
│   └── test/
│       └── java/
└── target/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						S12L12 - Wait and Notify in Java Multithreading/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/studyeasy/
│   │           └── Main.java
│   └── test/
│       └── java/
└── target/
					
				
			
		


पूर्वापेक्षाएँ

Java Development Kit (JDK) इंस्टॉल होना चाहिए।
Maven प्रोजेक्ट प्रबंधन के लिए।
IntelliJ IDEA या Eclipse जैसे एक एकीकृत विकास परिवेश (IDE)।

Wait और Notify मैकेनिज्म को लागू करना
आइए हमारे एप्लिकेशन के मुख्य हिस्से में जाएँ और बैंकिंग परिदृश्य के भीतर wait और notify तरीकों को लागू करें।
चरण-दर-चरण कार्यान्वयन
1. मुख्य क्लास बनाना




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}
 
					
				
			
		


व्याख्या:

Account: बैलेंस प्रबंधन के साथ बैंक खाता का प्रतिनिधित्व करता है।
WithdrawTask & DepositTask: निकासी और जमा ऑपरेशन्स के लिए Runnable कार्य।
Threads: समवर्ती रूप से निकासी और जमा को संभालने के लिए दो थ्रेड बनाए जाते हैं।

2. Account क्लास को परिभाषित करना




		
		
			
			
Java
			
			
package org.studyeasy;

public class Account {
    public static int balance = 0;

    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }

    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class Account {
    public static int balance = 0;
 
    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }
 
    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}
 
					
				
			
		


व्याख्या:

balance: उपयोगकर्ता के खाते के बैलेंस का प्रतिनिधित्व करने वाला साझा संसाधन।
withdraw(int amount):

जांचता है कि बैलेंस पर्याप्त है या नहीं।
यदि नहीं, तो थ्रेड जमा के लिए इंतजार करता है।
जैसे ही नोटिफाई किया जाता है, यह निकासी के साथ आगे बढ़ता है।


deposit(int amount):

जमा की गई राशि को बैलेंस में जोड़ता है।
बैलेंस अपडेट के बारे में प्रतीक्षा कर रहे थ्रेड्स को सूचित करता है।



3. Runnable कार्य बनाना




		
		
			
			
Java
			
			
package org.studyeasy;

public class WithdrawTask implements Runnable {
    private final Account account;

    public WithdrawTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.withdraw(1000);
    }
}

public class DepositTask implements Runnable {
    private final Account account;

    public DepositTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        try {
            // जमा में देरी को सिम्युलेट करना
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class WithdrawTask implements Runnable {
    private final Account account;
 
    public WithdrawTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        account.withdraw(1000);
    }
}
 
public class DepositTask implements Runnable {
    private final Account account;
 
    public DepositTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        try {
            // जमा में देरी को सिम्युलेट करना
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}
 
					
				
			
		


व्याख्या:

WithdrawTask: निर्दिष्ट राशि निकालने का प्रयास करता है।
DepositTask:

वास्तविक दुनिया की जमा परिदृश्यों को सिम्युलेट करने के लिए देरी जोड़ता है।
देरी के बाद जमा ऑपरेशन करता है।



पूर्ण प्रोग्राम कोड




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}

class Account {
    public static int balance = 0;

    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }

    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}

class WithdrawTask implements Runnable {
    private final Account account;

    public WithdrawTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.withdraw(1000);
    }
}

class DepositTask implements Runnable {
    private final Account account;

    public DepositTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        try {
            // जमा में देरी को सिम्युलेट करना
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}
 
class Account {
    public static int balance = 0;
 
    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }
 
    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}
 
class WithdrawTask implements Runnable {
    private final Account account;
 
    public WithdrawTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        account.withdraw(1000);
    }
}
 
class DepositTask implements Runnable {
    private final Account account;
 
    public DepositTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        try {
            // जमा में देरी को सिम्युलेट करना
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}
 
					
				
			
		


एप्लिकेशन चलाना
अपेक्षित आउटपुट




		
		
			
			
Java
			
			Thread-Withdraw: Waiting for deposit...
Thread-Deposit: Depositing amount...
Thread-Deposit: Deposit successful. Current Balance: 2000
Thread-Withdraw: Withdrawal successful. Current Balance: 1000
			
				
					
				
					1
2
3
4
				
						Thread-Withdraw: Waiting for deposit...
Thread-Deposit: Depositing amount...
Thread-Deposit: Deposit successful. Current Balance: 2000
Thread-Withdraw: Withdrawal successful. Current Balance: 1000
					
				
			
		


आउटपुट की व्याख्या

Thread-Withdraw शुरू होता है और $1000 निकालने का प्रयास करता है।
चूंकि प्रारंभिक बैलेंस $0 है, यह जमा के लिए इंतजार करता है।
Thread-Deposit शुरू होता है, 2 सेकंड की देरी को सिम्युलेट करता है, और फिर $2000 जमा करता है।
जमादार थ्रेड को नोटिस करता है।
Thread-Withdraw पुनः शुरू होता है, सफलतापूर्वक $1000 निकालता है, और बैलेंस को $1000 अपडेट करता है।

चरण-दर-चरण निष्पादन

Main Thread:

एक Account ऑब्जेक्ट बनाता है।
दो थ्रेड प्रारंभ करता है: एक निकासी के लिए और एक जमा के लिए।
दोनों थ्रेड शुरू करता है।


Thread-Withdraw:

withdraw(1000) को कॉल करता है।
बैलेंस ≤ 0 की जांच करता है; चूंकि है, प्रतीक्षा संदेश प्रिंट करता है और wait() को कॉल करता है।
प्रतीक्षा स्थिति में प्रवेश करता है।


Thread-Deposit:

देरी को सिम्युलेट करने के लिए 2 सेकंड के लिए सोता है।
deposit(2000) को कॉल करता है।
बैलेंस को 2000 में अपडेट करता है।
जमा सफलता संदेश प्रिंट करता है।
notify() को कॉल करता है ताकि प्रतीक्षा कर रहे निकासी थ्रेड को जगाया जा सके।


Thread-Withdraw:

wait() से जागता है।
$1000 निकालने के लिए आगे बढ़ता है।
बैलेंस को $1000 में अपडेट करता है।
निकासी सफलता संदेश प्रिंट करता है।



सामान्य समस्याएँ और समाधान
1. डेडलॉक्स
समस्या: गलत तरीके से wait और notify का उपयोग करने के कारण थ्रेड्स अनंत समय तक प्रतीक्षा करना।
समाधान:

सुनिश्चित करें कि हर wait() का एक समतुल्य notify() या notifyAll() हो।
वृत्ताकार प्रतीक्षा उत्पन्न करने वाले नेस्टेड सिंक्रनाइज़ेशन ब्लॉक्स से बचें।

2. मिस्ड नोटिफिकेशन्स
समस्या: एक थ्रेड notify() कॉल को मिस कर देता है, जिससे यह अनंत समय तक प्रतीक्षा करता है।
समाधान:

हमेशा wait() को एक लूप के भीतर करें जो स्थिति की जांच करता हो।
यह सुनिश्चित करता है कि थ्रेड जागने पर स्थिति को पुनः जांचे।

3. InterruptedException
समस्या: थ्रेड्स प्रतीक्षा करते समय InterruptedException फेंक सकते हैं।
समाधान:

अपवाद को पकड़कर इंटरप्शन्स को सुचारू रूप से संभालें।
वैकल्पिक रूप से, Thread.currentThread().interrupt() का उपयोग करके थ्रेड को पुनः इंटरप्ट करें।

4. अनुचित सिंक्रनाइज़ेशन
समस्या: साझा संसाधनों को सिंक्रनाइज़ नहीं करने से असंगत स्थिति उत्पन्न हो सकती है।
समाधान:

साझा संसाधनों तक पहुँच को नियंत्रित करने के लिए सिंक्रनाइज्ड मेथड्स या ब्लॉक्स का उपयोग करें।
सुनिश्चित करें कि दोनों wait() और notify() को सिंक्रनाइज्ड संदर्भ के भीतर बुलाया गया हो।

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

फायदे	नुकसान
कुशल थ्रेड कम्यूनिकेशन	यदि सही ढंग से प्रबंधित न किया जाए तो जटिल कोड हो सकता है
संसाधन प्रतिस्पर्धा को रोकता है	यदि सही ढंग से लागू न किया जाए तो डेडलॉक की संभावना
एप्लिकेशन के प्रदर्शन को बढ़ाता है	थ्रेड सिंक्रनाइज़ेशन की ठोस समझ की आवश्यकता

html


掌握Java多线程中的Wait和Notify：初学者的全面指南
目录

介绍
理解Java中的Wait和Notify
设置项目
实现Wait和Notify机制
运行应用程序
常见问题和故障排除
结论

介绍
在Java编程领域，多线程是一项强大的功能，允许开发人员同时执行多个操作，提升应用程序的效率和性能。在Java的各种同步机制中，wait和notify在管理线程通信和确保线程安全操作方面起着关键作用。
本指南深入探讨了Java多线程中的wait和notify概念，通过一个简单的银行场景提供逐步演示。无论您是初学者还是具有基础知识的开发人员，这篇全面的文章都将为您提供有效实现线程同步的必要见解。
理解Wait和Notify的重要性

线程协调：确保线程高效沟通而不会引起冲突。
资源管理：防止线程同时访问共享资源，避免不一致。
性能优化：通过有效管理线程执行提高应用程序性能。

优缺点


优点
缺点


高效的线程通信
如果管理不当，代码可能变得复杂


防止资源争用
如果实现不正确，可能导致死锁


提升应用性能
需要对线程同步有扎实的理解


何时何地使用Wait和Notify

何时：当线程需要就资源的可用性或任务的完成情况进行通信时，使用wait和notify。
何地：常用于生产者-消费者问题、银行交易以及任何需要协调线程执行的场景。

理解Java中的Wait和Notify
关键概念和术语

Thread：由Java虚拟机（JVM）管理的最小处理单元。
Synchronization：控制多个线程访问共享资源的机制。
wait()：使当前线程等待，直到另一个线程在同一对象上调用notify()或notifyAll()。
notify()：唤醒在对象监视器上等待的单个线程。

Wait和Notify的工作原理

wait()：

当线程调用wait()时，它会释放监视器（锁）并进入等待状态。
线程将保持在此状态，直到另一个线程在同一对象上调用notify()或notifyAll()。


notify()：

当线程调用notify()时，它会唤醒在对象监视器上等待的单个线程。
被唤醒的线程在当前线程释放监视器之前无法继续执行。



说明性图表

图1：线程同步中Wait和Notify机制之间的交互。
设置项目
为了演示wait和notify机制，我们将创建一个简单的Java应用程序，模拟一个银行场景，其中一个线程在允许取款之前等待存款。
项目结构




		
		
			
			
Java
			
			S12L12 - Wait and Notify in Java Multithreading/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/studyeasy/
│   │           └── Main.java
│   └── test/
│       └── java/
└── target/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						S12L12 - Wait and Notify in Java Multithreading/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/studyeasy/
│   │           └── Main.java
│   └── test/
│       └── java/
└── target/
					
				
			
		


前提条件

Java Development Kit (JDK) 已安装。
Maven 用于项目管理。
如IntelliJ IDEA或Eclipse等集成开发环境（IDE）。

实现Wait和Notify机制
让我们深入应用程序的核心，通过在银行场景中实现wait和notify方法。
逐步实现
1. 创建Main类




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}
 
					
				
			
		


解释：

Account：具有余额管理的银行账户。
WithdrawTask & DepositTask：用于取款和存款操作的Runnable任务。
Threads：创建两个线程，分别处理取款和存款。

2. 定义Account类




		
		
			
			
Java
			
			
package org.studyeasy;

public class Account {
    public static int balance = 0;

    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }

    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class Account {
    public static int balance = 0;
 
    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }
 
    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}
 
					
				
			
		


解释：

balance：表示用户账户余额的共享资源。
withdraw(int amount)：

检查余额是否足够。
如果不够，线程等待存款。
一旦被通知，继续进行取款。


deposit(int amount)：

将存入的金额添加到余额中。
通知等待的线程余额已更新。



3. 创建Runnable任务




		
		
			
			
Java
			
			
package org.studyeasy;

public class WithdrawTask implements Runnable {
    private final Account account;

    public WithdrawTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.withdraw(1000);
    }
}

public class DepositTask implements Runnable {
    private final Account account;

    public DepositTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        try {
            // 模拟存款延迟
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class WithdrawTask implements Runnable {
    private final Account account;
 
    public WithdrawTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        account.withdraw(1000);
    }
}
 
public class DepositTask implements Runnable {
    private final Account account;
 
    public DepositTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        try {
            // 模拟存款延迟
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}
 
					
				
			
		


解释：

WithdrawTask：尝试提取指定金额。
DepositTask：

引入延迟以模拟实际存款场景。
延迟后执行存款操作。



完整程序代码




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}

class Account {
    public static int balance = 0;

    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }

    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}

class WithdrawTask implements Runnable {
    private final Account account;

    public WithdrawTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.withdraw(1000);
    }
}

class DepositTask implements Runnable {
    private final Account account;

    public DepositTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        try {
            // 模拟存款延迟
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}
 
class Account {
    public static int balance = 0;
 
    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }
 
    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}
 
class WithdrawTask implements Runnable {
    private final Account account;
 
    public WithdrawTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        account.withdraw(1000);
    }
}
 
class DepositTask implements Runnable {
    private final Account account;
 
    public DepositTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        try {
            // 模拟存款延迟
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}
 
					
				
			
		


运行应用程序
预期输出




		
		
			
			
Java
			
			Thread-Withdraw: Waiting for deposit...
Thread-Deposit: Depositing amount...
Thread-Deposit: Deposit successful. Current Balance: 2000
Thread-Withdraw: Withdrawal successful. Current Balance: 1000
			
				
					
				
					1
2
3
4
				
						Thread-Withdraw: Waiting for deposit...
Thread-Deposit: Depositing amount...
Thread-Deposit: Deposit successful. Current Balance: 2000
Thread-Withdraw: Withdrawal successful. Current Balance: 1000
					
				
			
		


输出解释

Thread-Withdraw 开始并尝试提取$1000。
由于初始余额为$0，它等待存款。
Thread-Deposit 开始，模拟2秒的延迟，然后存入$2000。
存款后，它注意到等待的线程。
Thread-Withdraw 恢复，成功提取$1000，并将余额更新为$1000。

逐步执行

Main Thread：

创建一个 Account 对象。
初始化两个线程：一个用于取款，一个用于存款。
启动这两个线程。


Thread-Withdraw：

调用 withdraw(1000)。
检查余额是否 ≤ 0；因为是，它打印等待消息并调用 wait()。
进入等待状态。


Thread-Deposit：

睡眠2秒以模拟延迟。
调用 deposit(2000)。
将余额更新为2000。
打印存款成功消息。
调用 notify() 以唤醒等待的取款线程。


Thread-Withdraw：

从 wait() 中醒来。
继续提取$1000。
将余额更新为$1000。
打印取款成功消息。



常见问题和故障排除
1. 死锁
问题：由于不当使用 wait 和 notify，线程无限期等待。
解决方案：

确保每个 wait() 都有相应的 notify() 或 notifyAll()。
避免可能导致循环等待的嵌套同步块。

2. 忽略通知
问题：线程错过了 notify() 调用，导致其无限期等待。
解决方案：

始终在检查条件的循环中执行 wait()。
这确保了线程在醒来后重新检查条件。

3. InterruptedException
问题：线程在等待时可能会抛出 InterruptedException。
解决方案：

通过捕获异常来优雅地处理中断。
可选择使用 Thread.currentThread().interrupt() 重新中断线程。

4. 不当的同步
问题：未同步共享资源可能导致不一致的状态。
解决方案：

使用同步方法或块来控制对共享资源的访问。
确保 wait() 和 notify() 都在同步上下文中调用。

结论
掌握Java多线程中的wait和notify机制对于开发健壮且高效的应用程序至关重要。通过理解线程如何通信和同步，开发人员可以确保他们的应用程序无缝处理并发操作。
在本指南中，我们通过一个实际的银行场景探讨了wait和notify的实现。我们涵盖了项目设置、编写同步方法、处理线程通信以及故障排除常见问题。通过这些基础概念，您已充分准备好应对Java中更复杂的多线程挑战。
注意：本文由AI生成。

优点	缺点
高效的线程通信	如果管理不当，代码可能变得复杂
防止资源争用	如果实现不正确，可能导致死锁
提升应用性能	需要对线程同步有扎实的理解

html


Java 멀티스레딩에서 Wait와 Notify 마스터하기: 초보자를 위한 종합 가이드
목차

소개
Java에서 Wait와 Notify 이해하기
프로젝트 설정하기
Wait와 Notify 메커니즘 구현하기
애플리케이션 실행하기
일반적인 문제 및 문제 해결
결론

소개
Java 프로그래밍 영역에서, 멀티스레딩은 개발자들이 여러 작업을 동시에 수행할 수 있게 하는 강력한 기능으로, 애플리케이션의 효율성과 성능을 향상시킵니다. Java의 다양한 동기화 메커니즘 중에서, wait와 notify는 스레드 간 통신을 관리하고 스레드-안전한 작업을 보장하는 데 중요한 역할을 합니다.
이 가이드는 Java 멀티스레딩 내에서 wait와 notify 개념을 심도 있게 다루며, 간단한 은행 시나리오를 통해 단계별 시연을 제공합니다. 초보자이든 기본 지식을 가진 개발자이든, 이 종합적인 글은 스레드 동기화를 효과적으로 구현하는 데 필요한 통찰력을 제공할 것입니다.
Wait와 Notify 이해의 중요성

스레드 조정: 충돌 없이 스레드가 효율적으로 통신하도록 보장합니다.
자원 관리: 스레드가 공유 자원에 동시에 접근하는 것을 방지하여 불일치를 피합니다.
성능 최적화: 스레드 실행을 효과적으로 관리하여 애플리케이션 성능을 향상시킵니다.

장단점


장점
단점


효율적인 스레드 통신
적절히 관리되지 않으면 복잡한 코드로 이어질 수 있음


자원 경쟁 방지
잘못 구현하면 데드락 가능성


애플리케이션 성능 향상
스레드 동기화에 대한 확고한 이해 필요


Wait와 Notify를 언제 어디서 사용할까

언제: 스레드가 자원의 가용성이나 작업 완료에 대해 통신할 필요가 있을 때 wait와 notify를 사용합니다.
어디서: 생산자-소비자 문제, 은행 거래, 그리고 조정된 스레드 실행이 필요한 모든 상황에서 일반적으로 사용됩니다.

Java에서 Wait와 Notify 이해하기
핵심 개념 및 용어

Thread: Java Virtual Machine (JVM)이 관리할 수 있는 가장 작은 처리 단위입니다.
Synchronization: 여러 스레드가 공유 자원에 접근하는 것을 제어하는 메커니즘입니다.
wait(): 현재 스레드를 대기 상태로 만들어 다른 스레드가 동일한 객체에서 notify() 또는 notifyAll()을 호출할 때까지 기다리게 합니다.
notify(): 객체의 모니터에서 대기 중인 단일 스레드를 깨웁니다.

Wait와 Notify의 작동 방식

wait():

스레드가 wait()을 호출하면 모니터(잠금)를 해제하고 대기 상태로 들어갑니다.
다른 스레드가 동일한 객체에서 notify() 또는 notifyAll()을 호출할 때까지 이 상태를 유지합니다.


notify():

스레드가 notify()을 호출하면 객체의 모니터에서 대기 중인 단일 스레드를 깨웁니다.
깨워진 스레드는 현재 스레드가 모니터를 포기할 때까지 진행할 수 없습니다.



설명 도표

그림 1: 스레드 동기화에서 Wait와 Notify 메커니즘 간의 상호 작용.
프로젝트 설정하기
wait와 notify 메커니즘을 시연하기 위해, 한 스레드가 출금 전 예금을 기다리는 은행 시나리오를 시뮬레이션하는 간단한 Java 애플리케이션을 만들 것입니다.
프로젝트 구조




		
		
			
			
Java
			
			S12L12 - Wait and Notify in Java Multithreading/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/studyeasy/
│   │           └── Main.java
│   └── test/
│       └── java/
└── target/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						S12L12 - Wait and Notify in Java Multithreading/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/studyeasy/
│   │           └── Main.java
│   └── test/
│       └── java/
└── target/
					
				
			
		


사전 요구 사항

Java Development Kit (JDK)가 설치되어 있어야 합니다.
Maven을 통한 프로젝트 관리.
IntelliJ IDEA나 Eclipse와 같은 통합 개발 환경 (IDE).

Wait와 Notify 메커니즘 구현하기
이제 은행 시나리오에서 wait와 notify 메서드를 구현하여 애플리케이션의 핵심으로 들어가 봅시다.
단계별 구현
1. Main 클래스 생성하기




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}
 
					
				
			
		


설명:

Account: 잔액 관리를 하는 은행 계좌를 나타냅니다.
WithdrawTask & DepositTask: 출금 및 예금 작업을 위한 Runnable 작업.
Threads: 출금과 예금을 동시에 처리하기 위해 두 개의 스레드를 생성합니다.

2. Account 클래스 정의하기




		
		
			
			
Java
			
			
package org.studyeasy;

public class Account {
    public static int balance = 0;

    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }

    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class Account {
    public static int balance = 0;
 
    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }
 
    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}
 
					
				
			
		


설명:

balance: 사용자의 계좌 잔액을 나타내는 공유 자원입니다。
withdraw(int amount):

잔액이 충분한지 확인합니다。
충분하지 않으면, 스레드는 예금을 기다립니다。
알림을 받으면, 출금을 계속합니다。


deposit(int amount):

예금액을 잔액에 추가합니다。
잔액 업데이트에 대해 대기 중인 스레드에 알립니다。



3. Runnable 작업 생성하기




		
		
			
			
Java
			
			
package org.studyeasy;

public class WithdrawTask implements Runnable {
    private final Account account;

    public WithdrawTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.withdraw(1000);
    }
}

public class DepositTask implements Runnable {
    private final Account account;

    public DepositTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        try {
            // 예금 지연 시뮬레이션
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class WithdrawTask implements Runnable {
    private final Account account;
 
    public WithdrawTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        account.withdraw(1000);
    }
}
 
public class DepositTask implements Runnable {
    private final Account account;
 
    public DepositTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        try {
            // 예금 지연 시뮬레이션
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}
 
					
				
			
		


설명:

WithdrawTask: 지정된 금액을 출금하려고 시도합니다。
DepositTask:

실제 예금 시나리오를 시뮬레이션하기 위해 지연을 추가합니다。
지연 후 예금 작업을 수행합니다。



전체 프로그램 코드




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}

class Account {
    public static int balance = 0;

    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }

    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}

class WithdrawTask implements Runnable {
    private final Account account;

    public WithdrawTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.withdraw(1000);
    }
}

class DepositTask implements Runnable {
    private final Account account;

    public DepositTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        try {
            // 예금 지연 시뮬레이션
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}
 
class Account {
    public static int balance = 0;
 
    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }
 
    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}
 
class WithdrawTask implements Runnable {
    private final Account account;
 
    public WithdrawTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        account.withdraw(1000);
    }
}
 
class DepositTask implements Runnable {
    private final Account account;
 
    public DepositTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        try {
            // 예금 지연 시뮬레이션
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}
 
					
				
			
		


애플리케이션 실행하기
예상 출력




		
		
			
			
Java
			
			Thread-Withdraw: Waiting for deposit...
Thread-Deposit: Depositing amount...
Thread-Deposit: Deposit successful. Current Balance: 2000
Thread-Withdraw: Withdrawal successful. Current Balance: 1000
			
				
					
				
					1
2
3
4
				
						Thread-Withdraw: Waiting for deposit...
Thread-Deposit: Depositing amount...
Thread-Deposit: Deposit successful. Current Balance: 2000
Thread-Withdraw: Withdrawal successful. Current Balance: 1000
					
				
			
		


출력 설명

Thread-Withdraw가 시작되어 $1000을 출금하려고 시도합니다。
초기 잔액이 $0이므로, 예금을 기다립니다。
Thread-Deposit가 시작되어 2초간의 지연을 시뮬레이션한 후 $2000을 예금합니다。
예금 후, 대기 중인 스레드를 확인합니다。
Thread-Withdraw가 다시 시작되어 성공적으로 $1000을 출금하고, 잔액을 $1000으로 업데이트합니다。

단계별 실행

Main Thread:

하나의 Account 객체를 생성합니다。
출금을 위한 하나의 스레드와 예금을 위한 하나의 스레드를 초기화합니다。
두 스레드를 모두 시작합니다。


Thread-Withdraw:

withdraw(1000)을 호출합니다。
잔액이 ≤ 0인지 확인합니다；그렇기 때문에 대기 메시지를 출력하고 wait()을 호출합니다。
대기 상태에 들어갑니다。


Thread-Deposit:

지연을 시뮬레이션하기 위해 2초간 잠자기。
deposit(2000)을 호출합니다。
잔액을 2000으로 업데이트합니다。
예금 성공 메시지를 출력합니다。
notify()을 호출하여 대기 중인 출금 스레드를 깨웁니다。


Thread-Withdraw:

wait()에서 깨어납니다。
$1000을 출금합니다。
잔액을 $1000으로 업데이트합니다。
출금 성공 메시지를 출력합니다。



일반적인 문제 및 문제 해결
1. 데드락
문제: 부적절한 wait 및 notify 사용으로 인해 스레드가 무한정 대기하는 경우.
해결책：

모든 wait()에 해당하는 notify() 또는 notifyAll()이 있는지 확인합니다。
순환 대기를 초래할 수 있는 중첩 동기화 블록을 피합니다。

2. 알림 놓침
문제: 스레드가 notify() 호출을 놓쳐 무한정 대기하게 되는 경우.
해결책：

항상 조건을 확인하는 루프 내에서 wait()를 수행합니다。
이로써 스레드는 깨어난 후 조건을 재확인합니다。

3. InterruptedException
문제: 스레드가 대기 중일 때 InterruptedException을 던질 수 있습니다。
해결책：

예외를 잡아 중단을 우아하게 처리합니다。
선택적으로, Thread.currentThread().interrupt()를 사용하여 스레드를 다시 중단합니다。

4. 부적절한 동기화
문제: 공유 자원을 동기화하지 않으면 일관성 없는 상태로 이어질 수 있습니다。
해결책：

공유 자원에 대한 접근을 제어하기 위해 동기화된 메서드나 블록을 사용합니다。
동일한 객체 컨텍스트 내에서 wait()와 notify()을 호출하도록 합니다。

결론
Java 멀티스레딩에서 wait와 notify 메커니즘을 마스터하는 것은 견고하고 효율적인 애플리케이션을 개발하는 데 필수적입니다. 스레드가 어떻게 통신하고 동기화하는지 이해함으로써, 개발자들은 애플리케이션이 동시 작업을 원활하게 처리하도록 보장할 수 있습니다。
이 가이드에서는 wait와 notify의 구현을 보여주기 위해 실용적인 은행 시나리오를 탐구했습니다. 프로젝트 설정, 동기화된 메서드 작성, 스레드 통신 처리, 일반적인 문제 해결을 다루었습니다. 이러한 기초 개념을 통해, 여러분은 Java에서 더욱 복잡한 멀티스레딩 도전에 효과적으로 대응할 준비가 되어 있습니다。
참고: 이 글은 AI에 의해 생성되었습니다。

장점	단점
효율적인 스레드 통신	적절히 관리되지 않으면 복잡한 코드로 이어질 수 있음
자원 경쟁 방지	잘못 구현하면 데드락 가능성
애플리케이션 성능 향상	스레드 동기화에 대한 확고한 이해 필요

html


Dominando Wait e Notify em Java Multithreading: Um Guia Abrangente para Iniciantes
Índice

Introdução
Compreendendo Wait e Notify em Java
Configurando o Projeto
Implementando o Mecanismo Wait e Notify
Executando a Aplicação
Problemas Comuns e Soluções
Conclusão

Introdução
No âmbito da programação Java, o multithreading é um recurso poderoso que permite aos desenvolvedores realizar múltiplas operações simultaneamente, aumentando a eficiência e o desempenho das aplicações. Entre os diversos mecanismos de sincronização em Java, wait e notify são fundamentais para gerenciar a comunicação entre threads e garantir operações seguras.
Este guia explora os conceitos de wait e notify dentro do multithreading em Java, fornecendo uma demonstração passo a passo através de um cenário bancário simples. Seja você um iniciante ou um desenvolvedor com conhecimento básico, este artigo abrangente irá equipá-lo com os insights necessários para implementar a sincronização de threads de forma eficaz.
Importância de Compreender Wait e Notify

Coordenação de Threads: Garante que as threads se comuniquem de forma eficiente sem causar conflitos.
Gestão de Recursos: Evita que as threads acessem recursos compartilhados simultaneamente, evitando inconsistências.
Otimização de Desempenho: Melhora o desempenho da aplicação gerenciando a execução das threads de forma eficaz.

Prós e Contras


Prós
Contras


Comunicação eficiente entre threads
Pode levar a código complexo se não for gerenciado adequadamente


Previne competição por recursos
Potencial para deadlocks se não implementado corretamente


Melhora o desempenho da aplicação
Requer uma sólida compreensão da sincronização de threads


Quando e Onde Usar Wait e Notify

Quando: Use wait e notify quando as threads precisarem se comunicar sobre a disponibilidade de recursos ou a conclusão de tarefas.
Onde: Comumente usado em cenários como problemas de produtor-consumidor, transações bancárias e qualquer situação que exija execução coordenada de threads.

Compreendendo Wait e Notify em Java
Conceitos e Terminologia Chave

Thread: A menor unidade de processamento gerenciável pela Java Virtual Machine (JVM).
Synchronization: Mecanismo para controlar o acesso de múltiplas threads a recursos compartilhados.
wait(): Faz com que a thread atual espere até que outra thread invoque notify() ou notifyAll() no mesmo objeto.
notify(): Desperta uma única thread que está esperando no monitor do objeto.

Como Wait e Notify Funcionam

wait():

Quando uma thread chama wait(), ela libera o monitor (lock) e entra no estado de espera.
A thread permanece nesse estado até que outra thread invoque notify() ou notifyAll() no mesmo objeto.


notify():

Quando uma thread chama notify(), ela desperta uma única thread que está esperando no monitor do objeto.
A thread despertada não pode prosseguir até que a thread atual libere o monitor.



Diagrama Ilustrativo

Figura 1: Interação entre os mecanismos Wait e Notify na sincronização de threads.
Configurando o Projeto
Para demonstrar o mecanismo wait e notify, criaremos uma aplicação Java simples que simula um cenário bancário onde uma thread espera por um depósito antes de permitir um saque.
Estrutura do Projeto




		
		
			
			
Java
			
			S12L12 - Wait and Notify in Java Multithreading/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/studyeasy/
│   │           └── Main.java
│   └── test/
│       └── java/
└── target/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						S12L12 - Wait and Notify in Java Multithreading/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/studyeasy/
│   │           └── Main.java
│   └── test/
│       └── java/
└── target/
					
				
			
		


Pré-requisitos

Java Development Kit (JDK) instalado.
Maven para gestão do projeto.
Um Ambiente de Desenvolvimento Integrado (IDE) como IntelliJ IDEA ou Eclipse.

Implementando o Mecanismo Wait e Notify
Vamos nos aprofundar no núcleo da nossa aplicação implementando os métodos wait e notify dentro de um cenário bancário.
Implementação Passo a Passo
1. Criação da Classe Principal




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}
 
					
				
			
		


Explicação:

Account: Representa a conta bancária com gestão de saldo.
WithdrawTask & DepositTask: Tarefas Runnable para operações de saque e depósito.
Threads: Duas threads são criadas para lidar com saque e depósito simultaneamente.

2. Definindo a Classe Account




		
		
			
			
Java
			
			
package org.studyeasy;

public class Account {
    public static int balance = 0;

    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }

    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class Account {
    public static int balance = 0;
 
    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }
 
    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}
 
					
				
			
		


Explicação:

balance: Recurso compartilhado que representa o saldo da conta do usuário.
withdraw(int amount):

Verifica se o saldo é suficiente.
Se não for, a thread espera por um depósito.
Uma vez notificada, prossegue com o saque.


deposit(int amount):

Adiciona o valor depositado ao saldo.
Notifica as threads que estão aguardando sobre a atualização do saldo.



3. Criando Tarefas Runnable




		
		
			
			
Java
			
			
package org.studyeasy;

public class WithdrawTask implements Runnable {
    private final Account account;

    public WithdrawTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.withdraw(1000);
    }
}

public class DepositTask implements Runnable {
    private final Account account;

    public DepositTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        try {
            // Simulando atraso no depósito
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class WithdrawTask implements Runnable {
    private final Account account;
 
    public WithdrawTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        account.withdraw(1000);
    }
}
 
public class DepositTask implements Runnable {
    private final Account account;
 
    public DepositTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        try {
            // Simulando atraso no depósito
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}
 
					
				
			
		


Explicação:

WithdrawTask: Tenta sacar um valor especificado.
DepositTask:

Introduz um atraso para simular cenários de depósito do mundo real.
Realiza a operação de depósito após o atraso.



Código Completo do Programa




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}

class Account {
    public static int balance = 0;

    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }

    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}

class WithdrawTask implements Runnable {
    private final Account account;

    public WithdrawTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.withdraw(1000);
    }
}

class DepositTask implements Runnable {
    private final Account account;

    public DepositTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        try {
            // Simulando atraso no depósito
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}
 
class Account {
    public static int balance = 0;
 
    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }
 
    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}
 
class WithdrawTask implements Runnable {
    private final Account account;
 
    public WithdrawTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        account.withdraw(1000);
    }
}
 
class DepositTask implements Runnable {
    private final Account account;
 
    public DepositTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        try {
            // Simulando atraso no depósito
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}
 
					
				
			
		


Executando a Aplicação
Saída Esperada




		
		
			
			
Java
			
			Thread-Withdraw: Waiting for deposit...
Thread-Deposit: Depositing amount...
Thread-Deposit: Deposit successful. Current Balance: 2000
Thread-Withdraw: Withdrawal successful. Current Balance: 1000
			
				
					
				
					1
2
3
4
				
						Thread-Withdraw: Waiting for deposit...
Thread-Deposit: Depositing amount...
Thread-Deposit: Deposit successful. Current Balance: 2000
Thread-Withdraw: Withdrawal successful. Current Balance: 1000
					
				
			
		


Explicação da Saída

Thread-Withdraw inicia e tenta sacar $1000.
Como o saldo inicial é $0, ele espera por um depósito.
Thread-Deposit inicia, simula um atraso de 2 segundos e então deposita $2000.
Após o depósito, ele nota a thread que está esperando.
Thread-Withdraw retoma, saca $1000 com sucesso e atualiza o saldo para $1000.

Execução Passo a Passo

Main Thread:

Cria um objeto Account.
Inicializa duas threads: uma para saque e outra para depósito.
Inicia ambas as threads.


Thread-Withdraw:

Chama withdraw(1000).
Verifica se o saldo ≤ 0; como é, imprime a mensagem de espera e chama wait().
Entra no estado de espera.


Thread-Deposit:

Adormece por 2 segundos para simular atraso.
Chama deposit(2000).
Atualiza o saldo para 2000.
Imprime a mensagem de sucesso no depósito.
Chama notify() para despertar a thread de saque que está esperando.


Thread-Withdraw:

Acorda de wait().
Prossegue para sacar $1000.
Atualiza o saldo para $1000.
Imprime a mensagem de sucesso no saque.



Problemas Comuns e Soluções
1. Deadlocks
Problema: Threads esperando indefinidamente devido ao uso inadequado de wait e notify.
Solução：

Certifique-se de que cada wait() tenha um correspondente notify() ou notifyAll().
Evite blocos de sincronização aninhados que possam levar a espera circular.

2. Notificações Perdidas
Problema: Uma thread perde uma chamada de notify(), fazendo com que ela espere indefinidamente.
Solução：

Sempre execute wait() dentro de um loop que verifica a condição.
Isso garante que a thread re-verifique a condição ao acordar.

3. InterruptedException
Problema: Threads podem lançar InterruptedException durante a espera.
Solução：

Trate as interrupções graciosamente capturando a exceção.
Opcionalmente, reinterrompa a thread usando Thread.currentThread().interrupt().

4. Sincronização Inadequada
Problema: Falha em sincronizar recursos compartilhados pode levar a estados inconsistentes.
Solução：

Use métodos ou blocos sincronizados para controlar o acesso a recursos compartilhados.
Certifique-se de que tanto wait() quanto notify() sejam chamados dentro de um contexto sincronizado.

Conclusão
Dominar os mecanismos wait e notify no multithreading Java é essencial para desenvolver aplicações robustas e eficientes. Compreendendo como as threads comunicam e sincronizam, os desenvolvedores podem garantir que suas aplicações lidem com operações concorrentes de forma suave.
Neste guia, exploramos um cenário bancário prático para demonstrar a implementação de wait e notify. Abordamos configuração do projeto, escrita de métodos sincronizados, manejo da comunicação entre threads e solução de problemas comuns. Com esses conceitos fundamentais, você está bem equipado para enfrentar desafios mais complexos de multithreading em Java.
Nota: Este artigo foi gerado por IA.

Prós	Contras
Comunicação eficiente entre threads	Pode levar a código complexo se não for gerenciado adequadamente
Previne competição por recursos	Potencial para deadlocks se não implementado corretamente
Melhora o desempenho da aplicação	Requer uma sólida compreensão da sincronização de threads

html


Dominando Wait y Notify en Java Multithreading: Una Guía Completa para Principiantes
Tabla de Contenidos

Introducción
Comprendiendo Wait y Notify en Java
Configurando el Proyecto
Implementando el Mecanismo Wait y Notify
Ejecutando la Aplicación
Problemas Comunes y Solución de Problemas
Conclusión

Introducción
En el ámbito de la programación Java, el multithreading es una característica poderosa que permite a los desarrolladores realizar múltiples operaciones simultáneamente, mejorando la eficiencia y el rendimiento de las aplicaciones. Entre los diversos mecanismos de sincronización en Java, wait y notify son fundamentales para gestionar la comunicación entre hilos y asegurar operaciones seguras.
Esta guía profundiza en los conceptos de wait y notify dentro del multithreading en Java, proporcionando una demostración paso a paso a través de un escenario bancario simple. Ya seas un principiante o un desarrollador con conocimientos básicos, este completo artículo te equipará con las ideas necesarias para implementar la sincronización de hilos de manera efectiva.
Importancia de Comprender Wait y Notify

Coordinación de Hilos: Asegura que los hilos se comuniquen de manera eficiente sin causar conflictos.
Gestión de Recursos: Evita que los hilos accedan simultáneamente a recursos compartidos, evitando inconsistencias.
Optimización de Rendimiento: Mejora el rendimiento de la aplicación gestionando efectivamente la ejecución de los hilos.

Ventajas y Desventajas


Ventajas
Desventajas


Comunicación eficiente entre hilos
Pueda llevar a código complejo si no se gestiona correctamente


Previene la competencia por recursos
Potencial para deadlocks si no se implementa correctamente


Mejora el rendimiento de la aplicación
Requiere una sólida comprensión de la sincronización de hilos


Cuándo y Dónde Usar Wait y Notify

Cuándo: Usa wait y notify cuando los hilos necesiten comunicarse sobre la disponibilidad de recursos o la finalización de tareas.
Dónde: Comúnmente usado en escenarios como problemas de productor-consumidor, transacciones bancarias y cualquier situación que requiera una ejecución coordinada de hilos.

Comprendiendo Wait y Notify en Java
Conceptos Clave y Terminología

Thread: La unidad más pequeña de procesamiento que puede ser gestionada por la Java Virtual Machine (JVM).
Synchronization: Mecanismo para controlar el acceso de múltiples hilos a recursos compartidos.
wait(): Hace que el hilo actual espere hasta que otro hilo invoque notify() o notifyAll() en el mismo objeto.
notify(): Despierta a un único hilo que está esperando en el monitor del objeto.

Cómo Funcionan Wait y Notify

wait():

Cuando un hilo llama a wait(), libera el monitor (lock) y entra en estado de espera.
El hilo permanece en este estado hasta que otro hilo invoca notify() o notifyAll() en el mismo objeto.


notify():

Cuando un hilo llama a notify(), despierta a un único hilo que está esperando en el monitor del objeto.
El hilo despertado no puede proceder hasta que el hilo actual libere el monitor.



Diagrama Ilustrativo

Figura 1: Interacción entre los mecanismos Wait y Notify en la sincronización de hilos.
Configurando el Proyecto
Para demostrar el mecanismo wait y notify, crearemos una aplicación Java simple que simula un escenario bancario donde un hilo espera por un depósito antes de permitir un retiro.
Estructura del Proyecto




		
		
			
			
Java
			
			S12L12 - Wait and Notify in Java Multithreading/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/studyeasy/
│   │           └── Main.java
│   └── test/
│       └── java/
└── target/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						S12L12 - Wait and Notify in Java Multithreading/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/studyeasy/
│   │           └── Main.java
│   └── test/
│       └── java/
└── target/
					
				
			
		


Prerequisitos

Java Development Kit (JDK) instalado.
Maven para la gestión del proyecto.
Un Entorno de Desarrollo Integrado (IDE) como IntelliJ IDEA o Eclipse.

Implementando el Mecanismo Wait y Notify
Vamos a sumergirnos en el núcleo de nuestra aplicación implementando los métodos wait y notify dentro de un escenario bancario.
Implementación Paso a Paso
1. Creando la Clase Principal




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}
 
					
				
			
		


Explicación:

Account: Representa la cuenta bancaria con gestión de saldo.
WithdrawTask & DepositTask: Tareas Runnable para operaciones de retiro y depósito.
Threads: Se crean dos hilos para manejar retiros y depósitos simultáneamente.

2. Definiendo la Clase Account




		
		
			
			
Java
			
			
package org.studyeasy;

public class Account {
    public static int balance = 0;

    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }

    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class Account {
    public static int balance = 0;
 
    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }
 
    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}
 
					
				
			
		


Explicación:

balance: Recurso compartido que representa el saldo de la cuenta del usuario.
withdraw(int amount):

Verifica si el saldo es suficiente.
Si no lo es, el hilo espera por un depósito.
Una vez notificado, procede con el retiro.


deposit(int amount):

Agrega el monto depositado al saldo.
Notifica a los hilos que están esperando sobre la actualización del saldo.



3. Creando Tareas Runnable




		
		
			
			
Java
			
			
package org.studyeasy;

public class WithdrawTask implements Runnable {
    private final Account account;

    public WithdrawTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.withdraw(1000);
    }
}

public class DepositTask implements Runnable {
    private final Account account;

    public DepositTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        try {
            // Simulando demora en el depósito
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class WithdrawTask implements Runnable {
    private final Account account;
 
    public WithdrawTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        account.withdraw(1000);
    }
}
 
public class DepositTask implements Runnable {
    private final Account account;
 
    public DepositTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        try {
            // Simulando demora en el depósito
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}
 
					
				
			
		


Explicación:

WithdrawTask: Intenta retirar una cantidad especificada.
DepositTask:

Introduce una demora para simular escenarios de depósito del mundo real.
Realiza la operación de depósito después de la demora.



Código Completo del Programa




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}

class Account {
    public static int balance = 0;

    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }

    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}

class WithdrawTask implements Runnable {
    private final Account account;

    public WithdrawTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.withdraw(1000);
    }
}

class DepositTask implements Runnable {
    private final Account account;

    public DepositTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        try {
            // Simulando demora en el depósito
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}

			
				
					
				
					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
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}
 
class Account {
    public static int balance = 0;
 
    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }
 
    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}
 
class WithdrawTask implements Runnable {
    private final Account account;
 
    public WithdrawTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        account.withdraw(1000);
    }
}
 
class DepositTask implements Runnable {
    private final Account account;
 
    public DepositTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        try {
            // Simulando demora en el depósito
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}
 
					
				
			
		


Ejecutando la Aplicación
Salida Esperada




		
		
			
			
Java
			
			Thread-Withdraw: Waiting for deposit...
Thread-Deposit: Depositing amount...
Thread-Deposit: Deposit successful. Current Balance: 2000
Thread-Withdraw: Withdrawal successful. Current Balance: 1000
			
				
					
				
					1
2
3
4
				
						Thread-Withdraw: Waiting for deposit...
Thread-Deposit: Depositing amount...
Thread-Deposit: Deposit successful. Current Balance: 2000
Thread-Withdraw: Withdrawal successful. Current Balance: 1000
					
				
			
		


Explicación de la Salida

Thread-Withdraw comienza e intenta retirar $1000.
Como el saldo inicial es $0, espera por un depósito.
Thread-Deposit comienza, simula una demora de 2 segundos y luego deposita $2000.
Después del depósito, nota el hilo que está esperando.
Thread-Withdraw se reanuda, retira $1000 con éxito y actualiza el saldo a $1000.

Ejecución Paso a Paso

Main Thread:

Crea un objeto Account.
Inicializa dos hilos: uno para retiro y otro para depósito.
Inicia ambos hilos.


Thread-Withdraw:

Llama a withdraw(1000).
Verifica si el saldo ≤ 0; como lo es, imprime el mensaje de espera y llama a wait().
Entra en estado de espera.


Thread-Deposit:

Duerme por 2 segundos para simular la demora.
Llama a deposit(2000).
Actualiza el saldo a 2000.
Imprime el mensaje de éxito en el depósito.
Llama a notify() para despertar al hilo de retiro que está esperando.


Thread-Withdraw:

Se despierta de wait().
Procede a retirar $1000.
Actualiza el saldo a $1000.
Imprime el mensaje de éxito en el retiro.



Problemas Comunes y Solución de Problemas
1. Deadlocks
Problema: Hilos esperando indefinidamente debido al uso inadecuado de wait y notify.
Solución：

Asegúrese de que cada wait() tenga un correspondiente notify() o notifyAll().
Evite bloques de sincronización anidados que puedan llevar a espera circular.

2. Notificaciones Perdidas
Problema: Un hilo pierde una llamada a notify(), causándole esperar indefinidamente.
Solución：

Siempre realice wait() dentro de un ciclo que verifique la condición.
Esto asegura que el hilo re-chequee la condición al despertarse.

3. InterruptedException
Problema: Los hilos pueden lanzar InterruptedException al esperar.
Solución：

Maneje las interrupciones de manera graciosa atrapando la excepción.
Opcionalmente, reinterrumpa el hilo usando Thread.currentThread().interrupt().

4. Sincronización Inadecuada
Problema: No sincronizar recursos compartidos puede llevar a estados inconsistentes.
Solución：

Use métodos o bloques sincronizados para controlar el acceso a recursos compartidos.
Asegúrese de que tanto wait() como notify() se llamen dentro de un contexto sincronizado.

Conclusión
Dominar los mecanismos wait y notify en Java multithreading es esencial para desarrollar aplicaciones robustas y eficientes. Al comprender cómo los hilos comunican y sincronizan, los desarrolladores pueden asegurar que sus aplicaciones manejen operaciones concurrentes de manera fluida.
En esta guía, exploramos un escenario bancario práctico para demostrar la implementación de wait y notify. Cubrimos la configuración del proyecto, la escritura de métodos sincronizados, el manejo de la comunicación entre hilos y la solución de problemas comunes. Con estos conceptos fundamentales, estás bien equipado para enfrentar desafíos más complejos de multithreading en Java.
Nota: Este artículo fue generado por IA.

Ventajas	Desventajas
Comunicación eficiente entre hilos	Pueda llevar a código complejo si no se gestiona correctamente
Previene la competencia por recursos	Potencial para deadlocks si no se implementa correctamente
Mejora el rendimiento de la aplicación	Requiere una sólida comprensión de la sincronización de hilos