第三阶段：性能调优与设计模式

#### **1. JVM性能调优**

- **知识点**：
- 堆内存设置（`-Xms`、`-Xmx`）。
- GC日志分析。
- 性能监控工具（JVisualVM、Arthas）。

 

### 1. 堆内存设置（`-Xms`、`-Xmx`）

#### 详细解释
在 Java 中，堆内存是 Java 虚拟机（JVM）用于存储对象实例的内存区域。`-Xms` 和 `-Xmx` 是两个常用的 JVM 参数，用于设置堆内存的初始大小和最大大小。
- `-Xms`：指定 JVM 启动时堆内存的初始大小。例如，`-Xms512m` 表示 JVM 启动时堆内存的初始大小为 512MB。如果不设置该参数，JVM 会根据系统情况使用默认的初始堆大小。
- `-Xmx`：指定 JVM 堆内存的最大大小。例如，`-Xmx1024m` 表示 JVM 堆内存的最大大小为 1024MB。当堆内存使用达到最大大小时，如果还需要分配更多内存，就会触发垃圾回收（GC），如果 GC 后仍然无法满足内存需求，就会抛出 `OutOfMemoryError` 异常。

通常建议将 `-Xms` 和 `-Xmx` 设置为相同的值，这样可以避免堆内存的动态扩展和收缩，减少 GC 的频率，提高性能。

#### 示例
以下是一个简单的 Java 程序，用于测试堆内存设置：
```java
import java.util.ArrayList;
import java.util.List;

public class HeapMemoryExample {
public static void main(String[] args) {
List<byte[]> list = new ArrayList<>();
try {
while (true) {
// 不断创建新的字节数组，占用堆内存
list.add(new byte[1024 * 1024]);
}
} catch (OutOfMemoryError e) {
System.out.println("发生内存溢出错误: " + e.getMessage());
}
}
}
```
可以使用以下命令启动该程序，并设置堆内存的初始大小和最大大小：
```sh
java -Xms256m -Xmx256m HeapMemoryExample
```
在这个示例中，JVM 启动时堆内存的初始大小和最大大小都被设置为 256MB。程序会不断创建新的字节数组，占用堆内存，当堆内存使用达到 256MB 时，会抛出 `OutOfMemoryError` 异常。

### 2. GC 日志分析

#### 详细解释
GC 日志可以帮助我们了解 JVM 的垃圾回收情况，包括 GC 的触发原因、回收时间、回收前后的内存使用情况等。通过分析 GC 日志，我们可以找出内存泄漏、频繁 GC 等性能问题，并进行相应的优化。

要开启 GC 日志记录，可以在启动 JVM 时添加以下参数：
```plaintext
-XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:/path/to/gc.log
```
- `-XX:+PrintGCDetails`：打印详细的 GC 信息。
- `-XX:+PrintGCDateStamps`：打印 GC 发生的日期和时间。
- `-Xloggc:/path/to/gc.log`：将 GC 日志输出到指定的文件中。

#### 示例
以下是一段典型的 GC 日志示例：
```plaintext
2024-11-20T10:30:00.123+0800: 0.234: [GC (Allocation Failure) [PSYoungGen: 33280K->512K(38400K)] 33280K->10240K(125952K), 0.0103456 secs] [Times: user=0.03 sys=0.00, real=0.01 secs]
```
- **日期和时间**：`2024-11-20T10:30:00.123+0800` 表示 GC 发生的具体时间。
- **GC 触发原因**：`Allocation Failure` 表示由于对象分配失败触发了 GC。
- **新生代信息**：`[PSYoungGen: 33280K->512K(38400K)]` 表示新生代在 GC 前使用了 33280KB 内存，GC 后剩余 512KB 内存，新生代总容量为 38400KB。
- **堆内存信息**：`33280K->10240K(125952K)` 表示整个堆内存在 GC 前使用了 33280KB 内存，GC 后剩余 10240KB 内存，堆总容量为 125952KB。
- **GC 耗时**：`0.0103456 secs` 表示本次 GC 操作花费的时间。
- **CPU 时间**：`user=0.03 sys=0.00, real=0.01 secs` 分别表示用户态 CPU 时间、内核态 CPU 时间和实际耗时。

### 3. 性能监控工具（JVisualVM、Arthas）

#### JVisualVM
JVisualVM 是一个可视化的性能监控工具，它是 JDK 自带的工具，可以监控 Java 应用程序的内存使用、线程状态、CPU 使用率等信息。

**使用步骤**：
1. 启动 JVisualVM：在 JDK 的 `bin` 目录下找到 `jvisualvm.exe` 并运行。
2. 连接到目标 Java 应用程序：在 JVisualVM 的左侧列表中会显示当前运行的 Java 进程，选择要监控的进程。
3. 查看监控信息：在右侧的面板中可以查看内存、线程、CPU 等信息。例如，在“内存”选项卡中可以查看堆内存和非堆内存的使用情况，在“线程”选项卡中可以查看线程的状态和调用栈。

**示例**：
使用 JVisualVM 监控上面的 `HeapMemoryExample` 程序。启动程序后，打开 JVisualVM，找到 `HeapMemoryExample` 进程并连接。在“内存”选项卡中可以看到堆内存的使用情况随着程序的运行而不断增加，当达到最大堆内存时，会触发 GC，堆内存使用量会下降。

#### Arthas
Arthas 是 Alibaba 开源的一款 Java 诊断工具，它可以在不修改代码和重启应用的情况下，对 Java 应用进行实时诊断和监控。Arthas 提供了丰富的命令，如查看类加载信息、监控方法调用、查看线程状态等。

**使用步骤**：
1. 下载 Arthas：从 Arthas 的官方 GitHub 仓库下载 `arthas-boot.jar`。
2. 启动 Arthas：在命令行中运行 `java -jar arthas-boot.jar`，会列出当前运行的 Java 进程，选择要监控的进程。
3. 使用 Arthas 命令：连接到目标进程后，可以使用各种 Arthas 命令进行诊断和监控。例如，使用 `dashboard` 命令可以查看应用的实时概览信息，包括线程、内存、CPU 等；使用 `trace` 命令可以跟踪方法的调用情况。

**示例**：
启动 `HeapMemoryExample` 程序后，运行 `java -jar arthas-boot.jar`，选择 `HeapMemoryExample` 进程。然后使用 `dashboard` 命令查看应用的实时概览信息，包括线程数量、堆内存使用情况、CPU 使用率等。还可以使用 `trace` 命令跟踪 `HeapMemoryExample` 类的 `main` 方法的调用情况，了解方法的执行时间和调用路径。

通过堆内存设置、GC 日志分析和使用性能监控工具，我们可以更好地了解 Java 应用程序的性能状况，找出性能瓶颈并进行优化。

 

#### **2. 设计模式**
- **知识点**：
- 单例模式。
- 工厂模式。
- 观察者模式。
- 策略模式。

 

### 1. 单例模式
单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。

#### 饿汉式单例
```java
// 饿汉式单例，在类加载时就创建实例
public class EagerSingleton {
// 静态常量，在类加载时就初始化
private static final EagerSingleton INSTANCE = new EagerSingleton();

// 私有构造函数，防止外部实例化
private EagerSingleton() {}

// 公共静态方法，用于获取单例实例
public static EagerSingleton getInstance() {
return INSTANCE;
}
}
```
#### 使用示例
```java
public class EagerSingletonTest {
public static void main(String[] args) {
EagerSingleton singleton1 = EagerSingleton.getInstance();
EagerSingleton singleton2 = EagerSingleton.getInstance();
System.out.println(singleton1 == singleton2); // 输出 true，说明是同一个实例
}
}
```
#### 解释
- 饿汉式单例在类加载时就创建实例，因此是线程安全的。但如果这个单例对象在整个程序运行过程中可能不会被使用，就会造成资源浪费。

#### 懒汉式单例（线程不安全）
```java
// 懒汉式单例，在第一次使用时才创建实例
public class LazySingleton {
private static LazySingleton INSTANCE;

private LazySingleton() {}

public static LazySingleton getInstance() {
if (INSTANCE == null) {
INSTANCE = new LazySingleton();
}
return INSTANCE;
}
}
```
#### 解释
- 懒汉式单例在第一次调用 `getInstance()` 方法时才创建实例，避免了资源浪费。但在多线程环境下，可能会创建多个实例，线程不安全。

#### 懒汉式单例（线程安全，双重检查锁定）
```java
// 懒汉式单例，使用双重检查锁定保证线程安全
public class SafeLazySingleton {
private static volatile SafeLazySingleton INSTANCE;

private SafeLazySingleton() {}

public static SafeLazySingleton getInstance() {
if (INSTANCE == null) {
synchronized (SafeLazySingleton.class) {
if (INSTANCE == null) {
INSTANCE = new SafeLazySingleton();
}
}
}
return INSTANCE;
}
}
```
#### 解释
- 使用 `volatile` 关键字保证可见性，双重检查锁定机制确保在多线程环境下只有一个实例被创建。

### 2. 工厂模式
工厂模式是一种创建型设计模式，它定义了一个创建对象的接口，让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。

#### 简单工厂模式
```java
// 产品接口
interface Shape {
void draw();
}

// 具体产品类：圆形
class Circle implements Shape {
@Override
public void draw() {
System.out.println("绘制圆形");
}
}

// 具体产品类：矩形
class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("绘制矩形");
}
}

// 简单工厂类
class ShapeFactory {
public static Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase("CIRCLE")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
return new Rectangle();
}
return null;
}
}
```
#### 使用示例
```java
public class SimpleFactoryTest {
public static void main(String[] args) {
Shape circle = ShapeFactory.getShape("CIRCLE");
circle.draw();
Shape rectangle = ShapeFactory.getShape("RECTANGLE");
rectangle.draw();
}
}
```
#### 解释
- 简单工厂模式通过一个工厂类根据传入的参数来创建不同的产品对象。但如果需要添加新的产品，就需要修改工厂类的代码，不符合开闭原则。

### 3. 观察者模式
观察者模式是一种行为型设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。

#### 示例代码
```java
import java.util.ArrayList;
import java.util.List;

// 主题接口
interface Subject {
void registerObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers();
}

// 观察者接口
interface Observer {
void update(int state);
}

// 具体主题类
class ConcreteSubject implements Subject {
private int state;
private List<Observer> observers = new ArrayList<>();

public int getState() {
return state;
}

public void setState(int state) {
this.state = state;
notifyObservers();
}

@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}

@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}

@Override
public void notifyObservers() {
for (Observer observer : observers) {
observer.update(state);
}
}
}

// 具体观察者类
class ConcreteObserver implements Observer {
private String name;

public ConcreteObserver(String name) {
this.name = name;
}

@Override
public void update(int state) {
System.out.println(name + " 收到通知，状态更新为: " + state);
}
}
```
#### 使用示例
```java
public class ObserverPatternTest {
public static void main(String[] args) {
ConcreteSubject subject = new ConcreteSubject();

ConcreteObserver observer1 = new ConcreteObserver("观察者1");
ConcreteObserver observer2 = new ConcreteObserver("观察者2");

subject.registerObserver(observer1);
subject.registerObserver(observer2);

subject.setState(10);
}
}
```
#### 解释
- 主题对象维护一个观察者列表，当主题状态改变时，调用 `notifyObservers()` 方法通知所有观察者。观察者实现 `update()` 方法来处理状态更新。

### 4. 策略模式
策略模式是一种行为型设计模式，它定义了一系列的算法，并将每个算法封装起来，使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户端。

#### 示例代码
```java
// 策略接口
interface PaymentStrategy {
void pay(int amount);
}

// 具体策略类：信用卡支付
class CreditCardPayment implements PaymentStrategy {
@Override
public void pay(int amount) {
System.out.println("使用信用卡支付 " + amount + " 元");
}
}

// 具体策略类：支付宝支付
class AlipayPayment implements PaymentStrategy {
@Override
public void pay(int amount) {
System.out.println("使用支付宝支付 " + amount + " 元");
}
}

// 上下文类
class ShoppingCart {
private PaymentStrategy paymentStrategy;

public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
this.paymentStrategy = paymentStrategy;
}

public void checkout(int amount) {
paymentStrategy.pay(amount);
}
}
```
#### 使用示例
```java
public class StrategyPatternTest {
public static void main(String[] args) {
ShoppingCart cart = new ShoppingCart();

// 使用信用卡支付
cart.setPaymentStrategy(new CreditCardPayment());
cart.checkout(100);

// 使用支付宝支付
cart.setPaymentStrategy(new AlipayPayment());
cart.checkout(200);
}
}
```
#### 解释
- 策略接口定义了算法的行为，具体策略类实现了这些行为。上下文类持有一个策略接口的引用，根据需要切换不同的策略。