在 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 性能优化和虚拟线程实战。若你对文章内容深度、案例类型还有别的想法，欢迎随时告诉我。
997
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
