/>

2.

基础与调优：理解你的运行环境

Java

Java

的内存布局和运行时行为，就难以写出高性能的代码。

本节将深入探讨

JVM

内存主要分为以下几个运行时数据区：

• 程序计数器：线程私有，记录当前线程执行的字节码行号。

• Java

  虚拟机栈：线程私有，每个方法调用对应一个栈帧，存储局部变量表、操作数栈、动态链接、方法出口等。

  栈帧的大小在编译期确定。

  局部变量表中的引用可能指向堆中的对象。

• 本地方法栈：为

  native

  方法服务。

• 堆（Heap）：线程共享，所有对象实例和数组都在堆上分配。

  堆是垃圾收集器管理的主要区域，通常分为新生代（Eden、Survivor0、Survivor1）和老年代。

• 方法区（Metaspace，JDK8+）：线程共享，存储已被虚拟机加载的类型信息、常量、静态变量、即时编译器编译后的代码缓存等。

  JDK8

  之前称为永久代（PermGen），之后改为

  Metaspace，使用本地内存，减少

  OOM

  风险。

• 运行时常量池：方法区的一部分，存储编译期生成的字面量和符号引用。

性能影响：

• 栈上分配：如果对象不会逃逸出方法，JVM

  可能通过逃逸分析将其分配在栈上，方法结束后自动销毁，减轻

  压力。

• 堆的分代设计：新生代对象朝生夕死，老年代对象生命周期长。

  选择合适的

  算法和分代大小直接影响停顿时间和吞吐量。

2.2

垃圾收集器（GC）的选择与调优

GC

Java

算法适用于不同的场景：

• Serial

  GC：单线程收集，适用于单核、小型应用或客户端模式。

• Parallel

  GC：多线程并行收集，注重高吞吐量，适合后台计算任务。

  可通过-XX:+UseParallelGC启用。

• CMS（Concurrent

  Mark

  Sweep）：并发收集，低停顿，但会产生内存碎片。

  JDK9

  后废弃，推荐使用

  G1。

• G1（Garbage

  First）：服务端模式默认

  GC，将堆划分为多个

  Region，可预测停顿时间，兼顾吞吐量和低延迟。

  通过-XX:+UseG1GC启用。

• ZGC：JDK11

  引入，几乎无停顿（<10ms），支持

  级堆，适合大内存低延迟应用。

• Shenandoah：类似

  ZGC，也是低停顿收集器。

调优原则：

• 吞吐量优先：Parallel

  Scavenge

  次数。

• 响应时间优先：G1

  ZGC，设置期望的最大停顿时间-XX:MaxGCPauseMillis=200。

• 避免显式调用

  System.gc()：除非你确定需要

  Full

  日志：使用-Xloggc:gc.log

  -XX:+PrintGCDateStamps记录日志，并用工具（如

  GCeasy）分析。

2.3

JVM

参数

以下参数对性能影响显著：

• 堆大小：-Xms（初始堆）和-Xmx（最大堆）通常设为相同值，避免运行时动态调整。

• 新生代大小：-Xmn或-XX:NewRatio（老年代/新生代比例）。

  增大新生代可减少

  minor

  频率，但会增加老年代压力。

• 元空间大小：-XX:MetaspaceSize和-XX:MaxMetaspaceSize，防止类加载过多导致元空间无限增长。

• 线程栈大小：-Xss，默认

  1M，若递归深度小可适当减小。

• GC

  线程数：-XX:ParallelGCThreads和-XX:ConcGCThreads，根据

  CPU

  编译优化：JIT、内联与逃逸分析

  JVM

  通过即时编译器（JIT）将热点代码编译为本地机器码，大幅提升执行效率。

  • 分层编译：-XX:+TieredCompilation（默认开启），结合

    C1（客户端编译器，快速启动）和

    C2（服务端编译器，深度优化）。

  • 方法内联：JIT

    会将频繁调用的小方法内联到调用处，消除调用开销。

    通过-XX:MaxInlineSize控制内联方法的最大字节码大小（默认

    字节）。

  • 逃逸分析：-XX:+DoEscapeAnalysis（默认开启），分析对象作用域，若未逃逸出方法，可进行栈上分配、标量替换（将对象拆解为局部变量）或锁消除（移除无用同步）。

  • 锁消除：当

    JVM

    检测到不可能存在竞争时，会去掉同步块，提高并发性能。

  示例：锁消除

  java

  public
  String
  数据结构与算法：选对工具，事半功倍
  3.1
  集合框架提供了丰富的接口和实现，但错误的选择会导致性能下降。
  ArrayList
  LinkedList：ArrayList
  基于数组，随机访问
  O(1)，插入/删除（非末尾）需要移动元素
  基于双向链表，随机访问
  缓存友好且内存连续。
  除非频繁在列表中间插入删除，否则优先选用
  ArrayList。
  HashMap
  TreeMap：HashMap
  基于哈希表，查找
  O(1)（理想），需注意负载因子和初始容量，避免频繁
  O(log
  HashMap。
  HashSet
  TreeSet同理。
  EnumMap/EnumSet：若键为枚举类型，使用
  EnumMap，其内部用数组实现，性能远超
  HashMap。
  LinkedHashMap：保留插入顺序或访问顺序，可用于实现
  LRU
  缓存。
  初始化容量：对于已知大小的集合，应指定初始容量，避免扩容开销。
  java
  //
  已知元素数量为
  HashMap<>(2048);
  3.2
  并发集合与线程安全
  在多线程环境中，使用同步包装器（Collections.synchronizedXXX）会导致粗粒度的锁，性能低下。
  应优先使用java.util.concurrent包中的并发集合：
  ConcurrentHashMap：分段锁或
  CAS
  HashMap。
  CopyOnWriteArrayList：适用于读多写少的场景，每次修改创建底层数组副本，读操作无锁。
  BlockingQueue
  实现（如
  LinkedBlockingQueue）：用于生产者-消费者模式。
  ConcurrentLinkedQueue：无锁非阻塞队列，适用于高并发环境。
  3.3
  泛型不支持基本类型，导致频繁的自动装箱（int
  ->
  Integer）会创建大量临时对象，增加
  低效：循环中发生
  }

  若必须使用集合，可考虑第三方原始类型集合库，如Trove、FastUtil、HPPC，它们直接存储基本类型，避免装箱。

  java

  //
  Trove
  算法复杂度与数据规模考量
  选择合适的算法和数据结构，必须理解其时间复杂度和空间复杂度。
  对于大规模数据处理，O(n²)
  的算法可能无法接受。
  例如，排序时使用Arrays.sort()（快速排序/归并排序），不要自己写冒泡排序。
  对于查找，哈希表通常优于列表。
  此外，需注意常数因子的影响。
  例如，LinkedList
  O(1)
  头部插入虽快，但实际因为节点对象开销和内存分散，可能不如
  ArrayList
  中，创建一个对象不仅仅是分配内存，还包括构造器执行、可能的同步等。
  频繁创建短生命周期的对象会给
  带来负担。
  优化方向：减少对象数量，缩短对象存活时间。
  4.2
  对象池与重用
  对于创建开销大的对象（如数据库连接、线程、Socket），对象池是经典模式。
  但并非所有对象都适合池化，因为池本身也带来管理开销和线程竞争。
  线程池：使用ExecutorService，不要手动创建线程。
  数据库连接池：如
  HikariCP，性能极高。
  缓冲区重用：例如
  NIO
  ByteBuffer，可重复使用或使用池化。
  大对象复用：避免在循环中创建大数组或集合，尽量复用。
  java
  //
  低效：每次调用都创建新
  StringBuilder（但需注意线程安全）
  4.3
  GC，但仍可能发生内存泄漏，通常由无意中持有的对象引用导致。
  静态集合类：static
  List<Object>
  或设置最大容量。
  未关闭的资源：连接、流、监听器未关闭。
  务必在
  finally
  中关闭。
  内部类持有外部类引用：非静态内部类会隐式持有外部类实例，导致外部类无法回收。
  使用静态内部类或单独类。
  ThreadLocal
  在线程池中可能造成内存泄漏，因为线程复用，但
  ThreadLocal
  中调用remove()。
  缓存对象引用：使用软引用或弱引用包装缓存值。
  4.4
  引用类型（软、弱、虚）的正确用法
  强引用：普通引用，只要存在，对象不会被回收。
  软引用（SoftReference）：内存充足时不被回收，不足时回收。
  适合实现内存敏感缓存。
  弱引用（WeakReference）：下次
  时被回收。
  典型应用：WeakHashMap，键为弱引用，自动移除不用的键值对。
  虚引用（PhantomReference）：最弱，必须与引用队列配合，用于对象被回收后的资源清理（类似
  finalize
  但更安全）。
  示例：使用
  WeakHashMap
  作为缓存，当键对象不再被外部引用时，条目自动删除。
  java
  WeakHashMap<Key,
  Value>
  并发与多线程：挖掘多核潜力
  5.1
  Thread(...).start()会创建大量线程，导致资源耗尽和频繁上下文切换。
  必须使用线程池。
  ThreadPoolExecutor的核心参数：
  corePoolSize：核心线程数，即使空闲也保留。
  maximumPoolSize：最大线程数。
  keepAliveTime：非核心线程空闲存活时间。
  workQueue：任务队列，如LinkedBlockingQueue、SynchronousQueue。
  RejectedExecutionHandler：拒绝策略。
  Executors
  工厂方法的缺陷：
  newFixedThreadPool：队列无界（LinkedBlockingQueue），可能导致任务堆积
  OOM。
  newCachedThreadPool：最大线程无限，可导致创建大量线程。
  建议直接使用ThreadPoolExecutor自定义参数，并显式设置队列大小。
  java
  //
  自定义线程池示例
  Runtime.getRuntime().availableProcessors();
  int
  ArrayBlockingQueue<>(1000);
  ThreadPoolExecutor
  ThreadPoolExecutor.CallerRunsPolicy()
  );
  5.2
  锁的优化策略
  减小锁粒度：例如
  ConcurrentHashMap
  细粒度锁（JDK8）。
  读写锁（ReentrantReadWriteLock）：读多写少时，允许多个读并发，提高吞吐量。
  StampedLock：JDK8
  引入，支持乐观读，进一步提升读性能。
  避免锁粗化：JVM
  可能自动合并相邻同步块，但人为将无关操作放入同步块会降低并发。
  使用并发容器：如
  ConcurrentHashMap，避免显式同步。
  5.3
  无锁编程与原子变量
  利用
  CAS（Compare-And-Swap）硬件指令实现无锁编程，避免线程阻塞。
  原子类：AtomicInteger、AtomicLong、AtomicReference等，提供线程安全的变量操作。
  LongAdder：JDK8
  引入，比
  更适合高并发累加，通过分段减少竞争。
  Unsafe
  CAS
  操作，但通常不直接使用。
  示例：使用
  AtomicInteger
  实现计数器
  java
  public
  class
  框架用于分治任务，将大任务拆分为小任务，并行执行后合并结果。
  JDK8
  的并行流（parallelStream()）基于
  Fork/Join
  实现。
  注意：并行流并非银弹，需考虑任务粒度、数据竞争和线程池大小。
  默认使用公共
  ForkJoinPool，所有并行流共享，可能互相影响。
  可自定义
  ForkJoinPool。
  java
  //
  自定义
  list.parallelStream().forEach(...));
  5.5
  异步编程模型：CompletableFuture
  CompletableFuture
  提供了强大的异步编程能力，可以组合多个异步任务，避免回调地狱，提高响应性。
  java
  CompletableFuture.supplyAsync(()
  ->
  handleError(ex));
  性能优势：充分利用
  CPU
  I/O（BIO）基于流，每个连接一个线程，阻塞式读写，在高并发下线程数过多，上下文切换开销巨大。
  NIO（Non-blocking
  I/O）引入通道（Channel）和缓冲区（Buffer），以及多路复用器（Selector），一个线程可管理多个连接。
  BIO：适用于连接数少且固定的场景。
  NIO：适用于高并发、短连接场景，如
  Web
  模式）。
  6.2
  零拷贝技术
  零拷贝（Zero-Copy）技术减少数据在内核空间和用户空间之间的复制次数，提高
  I/O
  吞吐量。
  transferTo/transferFrom：FileChannel
  Socket，避免复制到用户空间。
  内存映射文件（MappedByteBuffer）：将文件映射到内存，读写操作直接操作内存，适合大文件处理。
  Netty
  FileRegion：封装零拷贝。
  6.3
  直接缓冲区（DirectBuffer）
  ByteBuffer
  分为堆缓冲区（HeapByteBuffer）和直接缓冲区（DirectByteBuffer）。
  直接缓冲区分配在堆外内存，读写时减少一次复制（堆到内核），适合网络
  I/O
  I/O。
  但创建和销毁成本较高，建议池化。
  java
  //
  分配直接缓冲区
  ByteBuffer.allocateDirect(1024);
  6.4
  原生序列化（ObjectOutputStream）性能差、体积大，且存在安全漏洞。
  应选择高性能序列化框架：
  Protobuf：Google
  出品，语言中立，性能高，体积小。
  Kryo：专为
  Java
  设计，速度极快，但需注意线程安全问题。
  Jackson
  JSON，但需选择启用
  等优化模块。
  Avro、Thrift等。
  6.5
  连接池与资源复用
  建立连接（如数据库连接、HTTP
  连接）开销大，必须使用连接池。
  数据库连接池：HikariCP
  性能最优，配置简单。
  HTTP
  Apache
  的连接池。
  连接池大小：并非越大越好，通常根据
  I/O
  密集型或计算密集型调整。
  数据库连接池大小可参考公式：线程数
  =
  等待时间/计算时间)。
  />
  7.
  代码微优化技巧：细节决定成败
  7.1
  循环优化
  提取不变表达式：将循环中不变的运算移出循环。
  java
  //
  for
  }
  减少方法调用：将频繁调用的方法结果缓存。
  使用增强
  for
  循环（foreach）：对于
  for
  循环可能略快（边界检查优化）。
  JVM
  会优化，差别不大。
  避免在循环中创建新对象。
  7.2
  字符串处理的陷阱
  字符串拼接：循环中使用+会创建大量
  StringBuilder
  StringBuilder。
  java
  //
  String
  sb.toString();
  String.split使用正则表达式，可能较慢。
  对于简单分隔符，可考虑StringTokenizer或indexOf+substring。
  String.intern()谨慎使用，可能永久代（元空间）溢出，且耗时。
  7.3
  异常处理的性能开销
  异常处理的成本很高，不应使用异常控制正常流程。
  抛出异常需填充堆栈信息，捕获异常也有开销。
  仅在真正异常时使用。
  java
  //
  try
  位运算与算术运算
  位运算速度极快，可替代部分乘除法。
  乘以
  <<
  15。
  判断奇偶：(x
  &
  0快。
  但需注意可读性，仅在高性能热点代码中使用。
  7.5
  延迟初始化与
  关键字
  延迟初始化：对于创建开销大且非必需的对象，可使用懒加载，但需注意线程安全（双重检查锁定或使用static内部类）。
  java
  //
  线程安全的懒加载单例（类初始化时创建）
  private
  }
  final
  JVM
  该字段不可变，有助于内联和优化。
  同时，final
  变量在多线程中提供安全发布。
  7.6
  缓存热点数据
  计算缓存：对于昂贵计算结果，可缓存起来重复使用。
  常量池：使用static
  final缓存常量对象，如BigDecimal.ZERO。
  方法内联缓存：JIT
  会自动内联，但代码设计应保持小方法，便于内联。
  />
  8.
  性能测试与分析：没有度量就没有优化
  8.1
  基准测试：JMH
  提供的微基准测试框架，用于准确测量代码片段性能。
  它能避免
  JVM
  优化带来的干扰（如死代码消除、常量折叠）。
  示例：测试字符串拼接性能
  java
  @BenchmarkMode(Mode.Throughput)
  @OutputTimeUnit(TimeUnit.MILLISECONDS)
  public
  预热之外的事，结果需结合统计信息判断。
  8.2
  性能剖析工具（Profiler）
  Profiler
  CPU
  热点、内存分配热点、锁竞争等。
  VisualVM：免费，内置
  CPU、内存、线程，支持插件。
  JProfiler：商业软件，功能强大，界面友好。
  YourKit：另一款优秀的商业
  Profiler。
  Async
  Linux
  AsyncGetCallTrace，低开销，可生成火焰图。
  使用
  Profiler
  时，应聚焦于应用程序繁忙时段，分析哪些方法占用最多
  CPU
  时间，或哪些对象分配最频繁。
  8.3
  日志分析
  开启
  GCeasy、GCEasy）分析：
  GC
  是否过于频繁？
  GC
  停顿时间：是否超过预期？
  晋升情况：对象过早晋升老年代可能引发
  Full
  GC。
  堆使用情况：是否接近上限？
  8.4
  火焰图与性能可视化
  火焰图（Flame
  CPU
  是事实上的企业级开发标准，但若不注意，可能引入性能开销。
  Bean
  每次获取新建，慎用。
  懒加载：使用@Lazy延迟初始化非必需
  Bean，加快启动速度。
  AOP
  代理：尽量使用编译期织入（AspectJ）而非运行时代理（JDK
  动态代理或
  CGLIB），但通常差别不大。
  避免过多拦截器：每个请求经过的拦截器链长度影响性能。
  Spring
  Boot
  自动配置：排除不必要的自动配置，减少启动时间。
  数据源配置：使用高性能连接池
  ORM
  框架（Hibernate/JPA）性能陷阱
  N+1
  查询问题：延迟加载导致循环查询，应使用
  JOIN
  一次加载所需关联。
  批量操作：使用@BatchSize或开启批量抓取。
  更新操作：避免不必要的字段更新，使用动态更新@DynamicUpdate。
  一级缓存与二级缓存：合理使用二级缓存减少数据库查询。
  原生
  SQL：对于复杂查询，可能比
  JPQL
  I/O，若同步写入磁盘，会阻塞业务线程。
  异步日志：Logback
  Log4j2
  AsyncAppender，将日志事件放入队列，由独立线程写入。
  惰性求值：使用占位符{}而非字符串拼接，避免不必要创建日志消息。
  java
  //
  log.debug("User:
  System.currentTimeMillis());
  若日志级别未开启
  DEBUG，参数不会进行字符串拼接。
  />
  10.
  字符串拼接的教训
  一个常见反模式：在循环中使用+拼接大量字符串，导致频繁创建
  StringBuilder
  过度同步的代价
  使用Collections.synchronizedList并在遍历时手动同步，仍可能因为迭代过程中其他线程修改导致异常。
  更严重的是，粗粒度锁降低并发。
  解决方案：使用CopyOnWriteArrayList或在迭代期间加锁。
  10.3
  大对象直接进入老年代
  如果创建了一个大对象（如长数组），超过了-XX:PretenureSizeThreshold，直接进入老年代。
  若该对象生命周期短，会导致老年代
  finalize()
  的危害
  finalize()方法由
  线程调用，执行时机不确定，且可能导致对象复活，性能低下且不可预测。
  应避免使用，改用Cleaner或PhantomReference管理资源。
  />
  11.
  结语：平衡性能与可维护性
  编写高性能
  Java
  代码并非追求极致的微优化，而是在理解系统瓶颈的基础上，做出合理的设计决策。
  过度优化会使代码难以阅读和维护，而忽视性能则可能导致系统不堪重负。
  最佳实践是：先写出清晰、正确的代码，再通过性能测试找出瓶颈，最后有针对性地优化关键路径。