在 Java 开发的世界里，性能优化是永恒的话题。当系统面临高并发、大数据量时，如何让 Java 应用程序保持高效运行，成为了每个开发者必须攻克的难题。接下来，我将分享自己通过 30 天时间，从 JVM 调优到实现百万级 QPS 的 Java 性能优化全历程，希望能给大家带来启发。

一、JVM 调优：性能优化的基石

JVM 作为 Java 程序运行的核心环境，其调优至关重要。首先要了解 JVM 的内存结构，包括堆内存、方法区、程序计数器、虚拟机栈和本地方法栈。其中，堆内存是对象分配的主要区域，也是调优的重点。

通过设置合理的堆内存大小参数，可以有效提升程序性能。例如，使用-Xms和-Xmx参数设置堆的初始大小和最大大小，避免频繁的内存扩展和收缩。如：

java -Xms1024m -Xmx4096m MyApp

同时，垃圾回收机制的选择也会影响性能。常见的垃圾回收器有 Serial、Parallel、CMS 和 G1 等。对于不同的应用场景，应选择合适的垃圾回收器。比如，对于响应时间敏感的应用，CMS 垃圾回收器可能是更好的选择，它能在垃圾回收过程中尽量减少应用程序的停顿时间。

二、多线程优化：提升并发处理能力

在高并发场景下，多线程技术是提升系统吞吐量的关键。但多线程也会带来线程安全、死锁等问题。为了优化多线程性能，可以从以下几个方面入手。

1. 线程池的合理使用

线程池可以避免频繁创建和销毁线程带来的开销。Java 提供了ExecutorService接口及其实现类ThreadPoolExecutor来创建线程池。通过设置合理的核心线程数、最大线程数、队列容量等参数，可以充分利用系统资源。例如：

ExecutorService executorService = new ThreadPoolExecutor( 5, // 核心线程数 10, // 最大线程数 60L, // 空闲线程存活时间 TimeUnit.SECONDS, new ArrayBlockingQueue<>(100) // 任务队列 );

2. 锁优化

在多线程环境中，锁的使用会影响性能。尽量减小锁的粒度，使用ConcurrentHashMap等线程安全的集合类代替加锁的普通集合类。对于读写操作频繁的场景，可以使用ReadWriteLock，允许多个线程同时读，但只允许一个线程写，从而提高并发性能。

三、数据库优化：提升数据访问效率

数据库是 Java 应用程序的重要组成部分，数据库性能的好坏直接影响整个系统的性能。

1. SQL 语句优化

编写高效的 SQL 语句是数据库优化的基础。避免使用SELECT *，明确指定需要查询的字段；合理使用索引，对经常用于查询条件、排序和连接的字段创建索引。例如，对于一个查询用户信息的 SQL 语句：

SELECT id, name, age FROM users WHERE age > 18 AND city = Beijing;

可以在age和city字段上创建复合索引，以加快查询速度。

2. 数据库连接池

使用数据库连接池可以减少数据库连接的创建和销毁开销。常见的数据库连接池有 C3P0、DBCP 和 HikariCP 等。HikariCP 以其高性能和低资源消耗受到广泛青睐，配置示例如下：

spring.datasource.hikari.driver-class-name=com.mysql.cj.jdbc.Driver spring.datasource.hikari.jdbc-url=jdbc:mysql://localhost:3306/mydb spring.datasource.hikari.username=root spring.datasource.hikari.password=123456

四、缓存技术：减少数据库压力

引入缓存可以将经常访问的数据存储在内存中，减少对数据库的访问次数，从而提高系统性能。常用的缓存框架有 Ehcache、Guava Cache 和 Redis 等。

以 Redis 为例，它是一个高性能的键值对数据库，可以作为缓存使用。在 Java 中，通过 Jedis 或 Lettuce 等客户端库可以方便地操作 Redis。例如，使用 Jedis 获取缓存数据：

Jedis jedis = new Jedis("localhost", 6379); String value = jedis.get("key"); if (value == null) { // 从数据库查询数据 value = queryFromDatabase(); jedis.set("key", value); } return value;

通过以上一系列的性能优化措施，经过 30 天的不断尝试和调整，最终实现了系统百万级 QPS 的目标。性能优化是一个持续的过程，需要不断学习和实践，希望大家在 Java 开发中也能打造出高性能的应用程序。

颠覆认知！Java 21 虚拟线程的 5 大实战场景，你用过几个？

Java 21 引入的虚拟线程，为 Java 开发者带来了全新的编程体验，它极大地简化了并发编程，提高了应用程序的性能和可扩展性。虚拟线程与传统的平台线程相比，具有轻量级、创建成本低等优势，能够轻松处理海量并发任务。下面将为大家介绍虚拟线程的 5 大实战场景，看看你是否已经应用到实际开发中。

一、高并发 Web 服务

在 Web 应用开发中，经常会面临高并发的请求。传统的线程模型在处理大量并发请求时，会因为线程数量过多而导致系统资源耗尽。而虚拟线程的出现，完美解决了这个问题。

以 Spring Boot 应用为例，通过在ThreadPoolTaskExecutor中配置虚拟线程工厂，可以轻松实现基于虚拟线程的高并发处理。首先，创建一个虚拟线程工厂：

import java.util.concurrent.ThreadFactory; import java.util.concurrent.Executors; import java.util.concurrent.VirtualThread; public class VirtualThreadFactory implements ThreadFactory { @Override public Thread newThread(Runnable r) { return VirtualThread.newThread(r); } }

然后，在 Spring Boot 的配置类中配置线程池：

import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; @Configuration public class ThreadPoolConfig { @Bean public ThreadPoolTaskExecutor taskExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setThreadFactory(new VirtualThreadFactory()); executor.setCorePoolSize(100); executor.setMaxPoolSize(1000); executor.setQueueCapacity(10000); return executor; } }

这样，当 Web 服务接收到大量请求时，虚拟线程能够快速响应，提高服务的吞吐量和响应速度。

二、异步批处理任务

在数据处理场景中，经常需要对大量数据进行异步批处理。例如，从数据库中读取大量数据，然后进行计算、转换等操作。使用虚拟线程可以轻松创建大量的异步任务，同时避免线程资源的浪费。

以下是一个简单的示例，使用虚拟线程对数据列表进行异步处理：

import java.util.ArrayList; import java.util.List; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; public class BatchProcessing { public static void main(String[] args) throws ExecutionException, InterruptedException { List<Integer> dataList = new ArrayList<>(); for (int i = 0; i < 1000; i++) { dataList.add(i); } List<CompletableFuture<Void>> futures = new ArrayList<>(); for (Integer data : dataList) { CompletableFuture<Void> future = CompletableFuture.runAsync(() -> { // 模拟数据处理操作 processData(data); }, new VirtualThreadFactory()); futures.add(future); } CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).get(); } private static void processData(int data) { // 具体的数据处理逻辑 System.out.println("Processing data: " + data); } }

通过这种方式，可以高效地处理大量数据，提高批处理任务的执行效率。

三、微服务调用优化

在微服务架构中，服务之间的调用通常是异步的。虚拟线程可以降低微服务调用过程中的线程切换开销，提高系统的整体性能。

当一个微服务需要调用多个其他微服务获取数据时，可以使用虚拟线程并行发起调用。例如，使用HttpClient发起 HTTP 请求：

import java.net.URI; import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.util.concurrent.CompletableFuture; public class MicroserviceCall { public static void main(String[] args) { HttpClient client = HttpClient.newHttpClient(); String url1 = "http://service1/api/data"; String url2 = "http://service2/api/data"; CompletableFuture<HttpResponse<String>> future1 = CompletableFuture.supplyAsync(() -> { try { HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(url1)) .build(); return client.send(request, HttpResponse.BodyHandlers.ofString()); } catch (Exception e) { throw new RuntimeException(e); } }, new VirtualThreadFactory()); CompletableFuture<HttpResponse<String>> future2 = CompletableFuture.supplyAsync(() -> { try { HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(url2)) .build(); return client.send(request, HttpResponse.BodyHandlers.ofString()); } catch (Exception e) { throw new RuntimeException(e); } }, new VirtualThreadFactory()); CompletableFuture.allOf(future1, future2).join(); try { HttpResponse<String> response1 = future1.get(); HttpResponse<String> response2 = future2.get(); // 处理响应数据 } catch (Exception e) { e.printStackTrace(); } } }

通过虚拟线程并行调用微服务，可以减少整体的响应时间，提升用户体验。

四、实时日志处理

在大型应用系统中，日志量通常非常庞大。实时处理日志数据，如日志分析、统计等，需要高效的并发处理能力。虚拟线程可以快速处理大量的日志数据，满足实时性要求。

例如，使用虚拟线程对日志文件进行实时读取和分析：

import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.concurrent.CompletableFuture; public class LogProcessing { public static void main(String[] args) { String logFilePath = "path/to/logfile.log"; CompletableFuture.runAsync(() -> { try (BufferedReader reader = new BufferedReader(new FileReader(logFilePath))) { String line; while ((line = reader.readLine()) != null) { // 分析日志数据 analyzeLog(line); } } catch (IOException e) { e.printStackTrace(); } }, new VirtualThreadFactory()); } private static void analyzeLog(String log) { // 具体的日志分析逻辑 System.out.println("Analyzing log: " + log); } }

通过这种方式，可以及时处理日志数据，为系统监控和故障排查提供有力支持。

五、大规模数据爬取

在数据采集领域，需要从大量的网页中爬取数据。由于网页数量众多，传统的线程模型难以高效处理。虚拟线程可以轻松创建大量的爬虫任务，快速获取数据。

以下是一个简单的网页爬虫示例：

import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.URL; import java.util.concurrent.CompletableFuture; public class WebCrawler { public static void main(String[] args) { String[] urls = {"http://example1.com", "http://example2.com", "http://example3.com"}; List<CompletableFuture<String>> futures = new ArrayList<>(); for (String url : urls) { CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> { try { URL obj = new URL(url); HttpURLConnection con = (HttpURLConnection) obj.openConnection(); con.setRequestMethod("GET"); BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream())); String inputLine; StringBuilder response = new StringBuilder(); while ((inputLine = in.readLine()) != null) { response.append(inputLine); } in.close(); return response.toString(); } catch (IOException e) { e.printStackTrace(); return ""; } }, new VirtualThreadFactory()); futures.add(future); } CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join(); try { for (CompletableFuture<String> future : futures) { String content = future.get(); // 处理爬取到的网页内容 } } catch (Exception e) { e.printStackTrace(); } } }

通过虚拟线程并行发起网页请求，可以大大提高数据爬取的效率。

Java 21 的虚拟线程为开发者提供了强大的并发编程工具，在上述 5 大场景以及更多的应用场景中都能发挥巨大的作用。希望大家能够深入学习和应用虚拟线程，提升自己的 Java 开发水平。

以上两篇文章分别聚焦 Java 性能优化和虚拟线程实战。若你对文章内容深度、案例类型还有别的想法，欢迎随时告诉我。