爆肝 30 天！从 JVM 调优到百万级 QPS，我的 Java 性能飞升全记录

在 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来创建线程池。通过设置合理的核心线程数、最大线程数、队列容量等参数，可以充分利用系统资源。例如：

java 复制代码

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

2. 锁优化

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

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

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

1. SQL 语句优化

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

ini 复制代码

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

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

2. 数据库连接池

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

ini 复制代码

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 获取缓存数据：

ini 复制代码

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中配置虚拟线程工厂，可以轻松实现基于虚拟线程的高并发处理。首先，创建一个虚拟线程工厂：

java 复制代码

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 的配置类中配置线程池：

java 复制代码

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 服务接收到大量请求时，虚拟线程能够快速响应，提高服务的吞吐量和响应速度。

二、异步批处理任务

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

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

java 复制代码

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 请求：

java 复制代码

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();
        }
    }
}

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

四、实时日志处理

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

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

java 复制代码

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);
    }
}

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

五、大规模数据爬取

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

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

java 复制代码

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 性能优化和虚拟线程实战。若你对文章内容深度、案例类型还有别的想法，欢迎随时告诉我。