S12L13 - Java多线程中的等待与通知续篇

html

掌握Java多线程中的Wait和Notify
目录

介绍 ………………………………………………………… 1
理解Java中的多线程 ……… 3
同步的重要性 ………… 5
探索Wait和Notify方法 ………….. 7

Wait方法
Notify和NotifyAll方法


实际实现：银行账户模拟 ………… 11

项目概述
代码解析
执行项目


常见陷阱与最佳实践 ………. 17
结论 ………………………………………………………….. 21


介绍
欢迎阅读 掌握Java多线程中的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类：

余额：表示账户的当前余额。
withdraw方法：

同步以防止并发访问。
检查余额是否充足。如果不充足，则等待存款。
使用wait(3000)等待3秒后继续执行。


deposit方法：

同步以确保线程安全。
将存款金额添加到余额。
调用notify()唤醒任何等待的取款线程。




Withdrawal类：

实现Runnable以在单独的线程中执行取款。
调用BankAccount的withdraw方法。


Deposit类：

实现Runnable以在单独的线程中执行存款。
睡眠2秒以模拟处理时间，然后调用deposit方法。


Main类：

创建Withdrawal和Deposit的实例。
启动两个线程，开始并发操作。



执行项目
运行Main类时，会发生以下事件序列：

取款线程：

尝试取款$1000。
如果资金不足，等待存款。


存款线程：

睡眠2秒以模拟处理延迟。
存款$2000。
通知等待的取款线程。


最终输出：

存款后取款完成，余额相应更新。



预期输出：




		
		
			
			
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。


死锁：

当两个或多个线程无限期地等待对方释放锁时发生。


使用notify而非notifyAll：

在多个线程可能等待的情景中，使用notify可能导致某些线程仍然被阻塞。



最佳实践

始终同步共享资源：

使用同步方法或块来控制对共享数据的访问。


在多个线程等待时使用notifyAll：

确保所有等待的线程都被通知，防止无限期阻塞。


最小化同步块的范围：

将同步限制在必要的最小代码段，以提高性能。


正确处理InterruptedException：

始终捕获并处理InterruptedException以保持线程的响应性。


避免使用带有任意超时的wait：

优选基于条件的等待，而非固定时间超时，以实现更可靠的线程协调。




结论
掌握wait和notify方法对于构建可靠和高效的Java多线程应用程序至关重要。通过理解同步机制并实施最佳实践，您可以有效地管理线程交互，确保数据完整性和优化性能。
关键要点：

同步：管理对共享资源的访问至关重要。
Wait和Notify：促进线程间的通信，允许协调执行。
最佳实践：遵循同步协议可以防止常见的线程问题，如死锁和竞争条件。

掌握这些概念，充分利用Java的多线程能力，为创建高性能和可扩展的应用程序铺平道路。
本文由AI生成。
特性	wait()	notify()
用途	使当前线程等待	唤醒等待的线程
释放锁	是	需要在同步块内
通知的线程数量	无（只是等待）	单个线程