四、系统级性能调优
4.1 JVM调优实战
/**
* JVM调优实战
*
* 调优目标：
* - 吞吐量：单位时间处理请求数
* - 延迟：GC暂停时间
* - 内存占用：堆内存使用
*
* 调优步骤：
* 1. 监控：GC日志、JMX、APM工具
* 2. 分析：GCViewer、VisualVM、MAT
* 3. 调整：参数优化、代码优化
* 4. 验证：压测验证效果
*/
public class JVMTuningPractice {
// GC日志分析关键指标
// - GC次数：Young GC、Full GC次数
// - GC耗时：平均耗时、最大耗时
// - 内存分配速率
// - 晋升速率
// - 对象存活率
// 常用JVM参数模板（4核8G服务）
/*
-Xms4g -Xmx4g // 堆内存4G
-Xmn2g // 新生代2G
-XX:SurvivorRatio=8 // Eden:S0:S1 = 8:1:1
-XX:+UseG1GC // 使用G1
-XX:MaxGCPauseMillis=100 // 目标暂停时间100ms
-XX:G1HeapRegionSize=16M // Region大小16M
-XX:InitiatingHeapOccupancyPercent=45 // 触发并发GC阈值
-XX:+PrintGCDetails -XX:+PrintGCDateStamps // GC日志
-Xloggc:gc.log // GC日志位置
-XX:+HeapDumpOnOutOfMemoryError // OOM时dump堆
-XX:HeapDumpPath=/data/dump // dump文件位置
*/
// OOM分析工具
// Eclipse MAT：分析堆dump，查找内存泄漏
// jmap -dump:live,format=b,file=heap.bin <pid>
// jstack <pid> > thread.dump // 线程dump分析死锁
// CPU飙升排查
// top -Hp <pid> // 查看线程CPU
// printf "%x\n" <thread-id> // 转换为16进制
// jstack <pid> | grep -A 20 <hex> // 查看线程栈
}
4.2 数据库调优
/**
* 数据库性能调优
*
* SQL优化
* - 避免SELECT *
* - 合理使用索引
* - 避免函数操作索引列
* - 使用EXPLAIN分析执行计划
*
* 连接池调优
* - HikariCP：maximumPoolSize = 核心数 * 2 + 磁盘数
* - 连接超时、空闲超时配置
*
* 分库分表
* - ShardingSphere
* - 水平分片：按ID取模
* - 垂直分片：按业务拆分
*
* 读写分离
* - 主库写，从库读
* - 注意主从延迟
*/
public class DatabaseTuning {
// 索引优化示例
// 联合索引最左前缀原则
// CREATE INDEX idx_name_age ON users(name, age);
// 有效查询：name = '张三'
// 有效查询：name = '张三' AND age = 25
// 无效查询：age = 25
// 分库分表策略
public static class ShardingStrategy {
// 范围分片
public static String rangeShard(long userId) {
if (userId < 1000000) {
return "db_0";
} else if (userId < 2000000) {
return "db_1";
}
return "db_2";
}
// 哈希分片
public static String hashShard(long orderId) {
long mod = orderId % 16;
return "table_" + mod;
}
// 一致性哈希
public static String consistentHash(String key) {
// 实现一致性哈希算法
return "node_" + (Math.abs(key.hashCode()) % 4);
}
}
// 慢查询优化示例
/*
-- 慢查询
SELECT * FROM orders WHERE YEAR(create_time) = 2024;
-- 优化后
SELECT * FROM orders WHERE create_time >= '2024-01-01'
AND create_time < '2025-01-01';
-- 分页优化（深分页问题）
-- 慢：SELECT * FROM orders LIMIT 100000, 20;
-- 快：SELECT * FROM orders WHERE id > 100000 LIMIT 20;
*/
}
五、架构模式与设计哲学
5.1 领域驱动设计（DDD）
/**
* 领域驱动设计（DDD）核心概念
*
* 战略设计
* - 限界上下文（Bounded Context）：业务边界
* - 上下文映射（Context Map）：上下文间关系
* - 核心域（Core Domain）：业务核心价值
*
* 战术设计
* - 实体（Entity）：有唯一标识
* - 值对象（Value Object）：无标识，不可变
* - 聚合（Aggregate）：事务边界，一致性保证
* - 领域服务（Domain Service）：跨实体业务逻辑
* - 领域事件（Domain Event）：业务事件
* - 仓库（Repository）：聚合的持久化接口
* - 工厂（Factory）：复杂对象创建
*/
public class DomainDrivenDesign {
// 聚合根示例
public static class Order {
private final OrderId id;
private OrderStatus status;
private final List<OrderItem> items = new ArrayList<>();
private final UserId userId;
public Order(OrderId id, UserId userId) {
this.id = id;
this.userId = userId;
this.status = OrderStatus.CREATED;
}
// 领域方法：封装业务规则
public void addItem(Product product, int quantity) {
if (status != OrderStatus.CREATED) {
throw new DomainException("订单状态不允许添加商品");
}
if (quantity <= 0) {
throw new DomainException("商品数量必须大于0");
}
items.add(new OrderItem(product, quantity));
}
public void submit() {
if (items.isEmpty()) {
throw new DomainException("订单不能为空");
}
this.status = OrderStatus.SUBMITTED;
// 发布领域事件
DomainEventPublisher.publish(new OrderSubmittedEvent(id));
}
public Money calculateTotal() {
return items.stream()
.map(OrderItem::getSubtotal)
.reduce(Money.ZERO, Money::add);
}
}
// 值对象
@Value
public static class Money {
public static final Money ZERO = new Money(0, "CNY");
private final BigDecimal amount;
private final String currency;
public Money add(Money other) {
if (!currency.equals(other.currency)) {
throw new IllegalArgumentException("货币单位不一致");
}
return new Money(amount.add(other.amount), currency);
}
}
// 领域事件
public static class OrderSubmittedEvent {
private final OrderId orderId;
private final LocalDateTime occurredAt;
public OrderSubmittedEvent(OrderId orderId) {
this.orderId = orderId;
this.occurredAt = LocalDateTime.now();
}
}
// 仓储接口（依赖倒置）
public interface OrderRepository {
Order findById(OrderId id);
void save(Order order);
}
// 领域服务
public static class PricingService {
private final DiscountPolicy discountPolicy;
public Money calculatePrice(Order order, User user) {
Money subtotal = order.calculateTotal();
Money discount = discountPolicy.calculate(order, user);
return subtotal.subtract(discount);
}
}
// 六边形架构（端口与适配器）
// 核心业务逻辑与技术实现分离
// 通过端口（接口）定义边界
// 适配器实现技术细节（数据库、消息、Web）
}
5.2 事件驱动架构
/**
* 事件驱动架构（EDA）
*
* 核心组件：
* - 事件（Event）：业务事实
* - 生产者（Producer）：发布事件
* - 消费者（Consumer）：处理事件
* - 消息代理（Message Broker）：事件路由
*
* 实现方案：
* - Kafka：高吞吐，持久化
* - RocketMQ：阿里开源，事务消息
* - RabbitMQ：灵活路由
* - Pulsar：云原生消息系统
*/
public class EventDrivenArchitecture {
// 事件定义
public static abstract class DomainEvent {
private final String eventId;
private final LocalDateTime occurredAt;
protected DomainEvent() {
this.eventId = UUID.randomUUID().toString();
this.occurredAt = LocalDateTime.now();
}
}
public static class OrderCreatedEvent extends DomainEvent {
private final OrderId orderId;
private final UserId userId;
private final Money amount;
public OrderCreatedEvent(OrderId orderId, UserId userId, Money amount) {
super();
this.orderId = orderId;
this.userId = userId;
this.amount = amount;
}
}
// 事件处理器
public interface EventHandler<T extends DomainEvent> {
void handle(T event);
}
// 事件总线
public static class EventBus {
private final Map<Class<?>, List<EventHandler<?>>> handlers = new ConcurrentHashMap<>();
public <T extends DomainEvent> void register(Class<T> eventType, EventHandler<T> handler) {
handlers.computeIfAbsent(eventType, k -> new CopyOnWriteArrayList<>())
.add(handler);
}
@SuppressWarnings("unchecked")
public void publish(DomainEvent event) {
List<EventHandler<?>> eventHandlers = handlers.get(event.getClass());
if (eventHandlers != null) {
for (EventHandler<?> handler : eventHandlers) {
((EventHandler<DomainEvent>) handler).handle(event);
}
}
}
}
// 事务性消息（RocketMQ）
// 保证本地事务和消息发送的一致性
public static class TransactionalMessage {
// 1. 发送半消息
// 2. 执行本地事务
// 3. 提交/回滚消息
// 4. 消息回查
}
// 事件溯源（Event Sourcing）
// 存储事件序列，通过重放事件重建状态
public static class EventSourcedAggregate {
private final List<DomainEvent> changes = new ArrayList<>();
protected void applyChange(DomainEvent event) {
// 应用事件到聚合状态
changes.add(event);
}
public List<DomainEvent> getUncommittedChanges() {
return changes;
}
public void markChangesAsCommitted() {
changes.clear();
}
public void loadFromHistory(List<DomainEvent> history) {
for (DomainEvent event : history) {
// 重放历史事件重建状态
applyChange(event);
}
changes.clear();
}
}
}
六、Java高阶学习路径
6.1 知识体系图谱
Java高阶知识
├── JVM底层
│ ├── 内存模型与GC算法
│ ├── 字节码与类加载
│ ├── JIT编译优化
│ └── JVM调优实战
├── 并发深度
│ ├── JMM与Happens-Before
│ ├── 无锁编程
│ ├── 并发数据结构
│ └── 异步编程模型
├── 分布式系统
│ ├── CAP/BASE理论
│ ├── 共识算法（Paxos/Raft）
│ ├── 分布式事务
│ └── 服务网格
├── 高并发设计
│ ├── 限流熔断降级
│ ├── 缓存架构
│ ├── 消息队列
│ └── 分库分表
├── 架构模式
│ ├── 领域驱动设计
│ ├── 事件驱动架构
│ ├── 微服务架构
│ └── Serverless
└── 性能调优
├── JVM调优
├── 数据库调优
├── 操作系统调优
└── 网络调优
Java高阶知识是一条永无止境的探索之路。从JVM底层的内存布局到垃圾回收算法的精妙设计，从并发编程的内存模型到无锁数据结构的高效实现，从分布式系统的CAP理论到微服务架构的工程实践，每一步深入都让你对这门语言的理解更加透彻。
来源：
https://app-a7illrp9pngh.appmiaoda.com/
