S12L12 - Java多线程中的等待与通知

html

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

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

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

Thread Coordination: 确保 threads 高效通信而不产生冲突。
资源管理: 防止 threads 同时访问共享资源，避免不一致性。
性能优化: 通过有效管理 thread 执行来提升应用程序性能。

优点与缺点


优点
缺点


高效的 thread 通信
如果管理不当，可能导致代码复杂


防止资源竞争
如果实现不当，可能会导致死锁


提升应用程序性能
需要对 thread synchronization 有深入理解


何时以及在何处使用 Wait 和 Notify

何时: 当 threads 需要就资源的可用性或任务的完成进行通信时，使用 wait 和 notify。
在何处: 常用于生产者-消费者问题、银行交易等任何需要 thread 协调执行的场景。

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

Thread: Java 虚拟机 (JVM) 可以管理的最小处理单元。
Synchronization: 机制来控制多个 threads 访问共享资源。
wait(): 引起当前 thread 等待，直到另一个 thread 在同一对象上调用 notify() 或 notifyAll()。
notify(): 唤醒在对象监视器上等待的单个 thread。

Wait 和 Notify 如何工作

wait():

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


notify():

当一个 thread 调用 notify() 时，它唤醒在对象的监视器上等待的单个 thread。
被唤醒的 thread 不能继续执行，直到当前 thread 释放监视器。



示意图

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




		
		
			
			
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: 两个 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):

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


deposit(int amount):

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



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 {
            // Simulating delay in deposit
            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 {
            // Simulating delay in deposit
            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 {
            // Simulating delay in deposit
            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 {
            // Simulating delay in deposit
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}
 
					
				
			
		


运行应用程序
预期输出




		
		
			
			
Java
			
			Thread-Withdraw: 等待存款...
Thread-Deposit: 存款中...
Thread-Deposit: 存款成功。当前余额：2000
Thread-Withdraw: 取款成功。当前余额：1000
			
				
					
				
					1
2
3
4
				
						Thread-Withdraw: 等待存款...
Thread-Deposit: 存款中...
Thread-Deposit: 存款成功。当前余额：2000
Thread-Withdraw: 取款成功。当前余额：1000
					
				
			
		


输出解释

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

分步执行

Main Thread:

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


Thread-Withdraw:

调用 withdraw(1000)。
检查 balance ≤ 0；由于是，打印等待消息并调用 wait()。
进入等待状态。


Thread-Deposit:

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


Thread-Withdraw:

从 wait() 中唤醒。
继续取款 $1000。
更新 balance 为 $1000。
打印取款成功消息。



常见问题及故障排除
1. 死锁
问题: 因不当使用 wait 和 notify 导致 threads 无限期等待。
解决方案:

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

2. 漏失通知
问题: 一个 thread 错过了 notify() 调用，导致它无限期等待。
解决方案:

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

3. InterruptedException
问题: threads 等待时可能会抛出 InterruptedException。
解决方案:

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

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

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

结论
掌握 Java 多线程中的 wait 和 notify 机制对于开发稳健且高效的应用程序至关重要。通过理解 threads 如何通信和同步，开发人员可以确保他们的应用程序无缝处理并发操作。
在本指南中，我们探索了一个实际的银行场景来演示 wait 和 notify 的实现。我们涵盖了项目设置、编写同步方法、处理 thread 通信以及故障排除常见问题。凭借这些基础概念，您已具备应对 Java 中更复杂的多线程挑战的能力。
注意: 本文由 AI 生成。
优点	缺点
高效的 thread 通信	如果管理不当，可能导致代码复杂
防止资源竞争	如果实现不当，可能会导致死锁
提升应用程序性能	需要对 thread synchronization 有深入理解