高性能JAVA

​1.Stream 并行流处理计算密集型任务，适用于 CPU 密集型计算，利用多核并行处理。

// 创建包含 0 到 999,999 的整数列表（总数据量 100 万）
List<Integer> numbers = IntStream.range(0, 1_000_000).boxed().collect(Collectors.toList());

// 串行处理：顺序累加所有元素
long sumSerial = numbers.stream().mapToLong(Integer::longValue).sum();

// 并行处理：通过多线程分块加速计算（数据量大时加速明显）
long sumParallel = numbers.parallelStream().mapToLong(Integer::longValue).sum();

2.使用原生数组代替集合减少对象开销，提升内存局部性。

public static void main(String[] args) {
    // 创建包含 1,000,000 个元素的整型数组
    int[] array = new int[1_000_000];
    
    // 快速填充数组：每个元素的值等于其索引（0, 1, 2, ..., 999999）
    Arrays.setAll(array, i -> i); 
    
    // 并行计算前缀和：array[i] = array[0](@ref) + array[1](@ref) + ... + array[i]
    Arrays.parallelPrefix(array, (a, b) -> a + b); 
    
    // 输出数组对象（实际应用中应遍历或获取具体值）
    System.out.println(Arrays.toString(array));
}

3.避免装箱操作默认线程数为 CPU 核心数，可通过 JVM 参数全局调整

public static void main(String[] args) {
    System.out.println(
        IntStream.range(0, 1_000_000)   // 生成 0 到 999,999 的整数流
            .parallel()                 // 启用并行处理（底层基于 Fork/Join 框架）
            .sum()                     // 并行累加所有元素
    );
}

4.并发与多线程优化

// 创建 LongAdder 实例（高性能并发计数器）
LongAdder adder = new LongAdder();

// 启动 100 个线程，每个线程执行 1000 次累加操作
List<Thread> threads = new ArrayList<>();
for (int i = 0; i < 100; i++) {
    threads.add(new Thread(() -> {
        for (int j = 0; j < 1000; j++) {
            adder.increment(); // 无锁自增操作
        }
    }));
}

// 启动并等待所有线程完成
threads.forEach(Thread::start);
threads.forEach(t -> {
    try { t.join(); } catch (InterruptedException e) {}
});

// 输出最终累加结果（预期：100 * 1000 = 100000）
System.out.println(adder.sum());

5.高性能队列（Disruptor库）适用于极高吞吐量的生产者-消费者场景。

// 定义事件
        class LogEvent {
            // 私有字段
            private String message;

            // Getter 方法：用于获取 message 的值
            public String getMessage() {
                return message;
            }

            // Setter 方法：用于设置 message 的值
            public void setMessage(String message) {
                this.message = message;
            }
        }
// 初始化 Disruptor
        Disruptor<LogEvent> disruptor = new Disruptor<>(
                LogEvent::new, 1024, DaemonThreadFactory.INSTANCE);

// 消费者处理
        disruptor.handleEventsWith((event, sequence, endOfBatch) -> {
            System.out.println("Processing: " + event.getMessage());
        });

// 启动并发布事件
        RingBuffer<LogEvent> ringBuffer = disruptor.start();
        ringBuffer.publishEvent((event, sequence) -> event.setMessage("Hello Disruptor!"));
    }

6.虚拟线程（Java 19+）轻量级线程，适用于高并发 IO 密集型任务。

try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        });
    });
} // 自动关闭 ExecutorService

7.IO 与网络优化 NIO 非阻塞网络编程

// 使用 Java NIO 实现非阻塞 Echo 服务器
try (ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
    serverChannel.bind(new InetSocketAddress(8080));
    serverChannel.configureBlocking(false);
    Selector selector = Selector.open();
    serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    
    while (true) {
        selector.select();
        Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
        while (keys.hasNext()) {
            SelectionKey key = keys.next();
            keys.remove();
            if (key.isAcceptable()) {
                SocketChannel client = serverChannel.accept();
                client.configureBlocking(false);
                client.register(selector, SelectionKey.OP_READ);
            } else if (key.isReadable()) {
                SocketChannel client = (SocketChannel) key.channel();
                ByteBuffer buffer = ByteBuffer.allocate(256);
                client.read(buffer);
                buffer.flip();
                client.write(buffer);
                buffer.clear();
            }
        }
    }
}

8.文件读写优化（内存映射文件）

try (RandomAccessFile file = new RandomAccessFile("largefile.dat", "rw");
     FileChannel channel = file.getChannel()) {
    MappedByteBuffer buffer = channel.map(
        FileChannel.MapMode.READ_WRITE, 0, channel.size());
    // 直接操作内存，避免系统调用
    for (int i = 0; i < buffer.limit(); i++) {
        byte b = buffer.get(i);
        buffer.put(i, (byte) (b + 1));
    }
}

10.JVM 调优参数

================垃圾回收器选择============
# G1 GC（平衡吞吐量和延迟）
java -XX:+UseG1GC -Xmx4g -XX:MaxGCPauseMillis=200 -jar app.jar

# ZGC（亚毫秒级暂停）
java -XX:+UseZGC -Xmx16g -Xlog:gc* -jar app.jar

# Shenandoah（低延迟并发压缩）
java -XX:+UseShenandoahGC -Xmx8g -jar app.jar
=============内存分配优化==============
# 调整堆和元空间
-Xms4g -Xmx4g -XX:MetaspaceSize=256m -XX:MaxMetaspaceSize=512m

# 直接内存分配（NIO使用）
-XX:MaxDirectMemorySize=1g
===========JIT 编译参数==========
# 启用分层编译
-XX:+TieredCompilation

# 调整代码缓存大小
-XX:ReservedCodeCacheSize=256m