并发性能终极对决：Go goroutine VS Java JUC 全方位测试

原创

已于 2024-11-02 14:23:28 修改 · 1.6k 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#python #java #golang #后端 #性能优化 #linux #github

于 2024-11-02 13:49:15 首次发布

全网首发2万字长文，做技术博客我是认真的

项目地址

主要开发语言为go,java,shell,python

Go 与 Java 并发性能对比测试套件

前言

在现代分布式系统和高并发应用开发中，并发处理能力已成为衡量编程语言和框架性能的关键指标。Go 语言以其轻量级的 goroutine 和优秀的并发模型而闻名，而 Java 则凭借其成熟的 JUC (Java Util Concurrent) 并发框架在企业级应用中广受欢迎。本测试套件旨在通过科学、客观的方法对这两种语言的并发处理能力进行全面的对比分析。

测试目标

并发处理能力
- 评估不同并发级别下的性能表现
- 测试系统在高负载情况下的稳定性
- 对比内存使用效率和资源消耗
实际应用场景
- 模拟真实业务场景下的并发处理
- 评估不同类型任务的处理能力
- 分析在长时间运行下的性能表现
系统资源利用
- 监控 CPU 使用情况
- 分析内存分配和回收
- 评估网络 I/O 效率

测试范围

并发模型对比
- Go: goroutine + channel
- Java: Thread Pool + JUC 组件
应用场景覆盖
- CPU 密集型任务
- I/O 密集型任务
- 混合型任务处理
性能指标采集
- 吞吐量 (Throughput)
- 响应时间 (Response Time)
- 资源利用率 (Resource Utilization)
- GC 影响 (Garbage Collection Impact)

预期价值

技术选型参考
- 为不同场景下的技术选型提供数据支持
- 帮助开发团队做出更明智的架构决策
性能优化指导
- 识别各自语言的性能瓶颈
- 提供针对性的优化建议
最佳实践总结
- 总结并发编程的最佳实践
- 提供实用的性能调优方法

使用说明

本测试套件采用模块化设计，使用者可以根据实际需求选择性运行测试用例。测试结果将通过图表和详细报告的形式展现，便于分析和决策。

注意事项

测试结果会受到硬件环境的影响，建议在相同配置下进行对比
真实业务场景可能与测试用例有所差异，请结合实际情况解读结果
性能测试应在专用环境中进行，避免其他程序干扰

接下来将详细介绍测试套件的安装、配置和使用方法，以及如何解读测试结果和进行性能优化。

1. 测试代码:

Go 版本 (concurrent_test.go):

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
    "time"
    "runtime"
)

type Counter struct {
   
   
    count int64
}

func (c *Counter) Increment() {
   
   
    atomic.AddInt64(&c.count, 1)
}

func (c *Counter) GetCount() int64 {
   
   
    return atomic.LoadInt64(&c.count)
}

func main() {
   
   
    // 设置使用的CPU核心数
    runtime.GOMAXPROCS(runtime.NumCPU())
    
    tests := []struct {
   
   
        goroutines int
        tasks      int
    }{
   
   
        {
   
   100, 10000},
        {
   
   1000, 10000},
        {
   
   5000, 10000},
        {
   
   10000, 10000},
    }

    for _, test := range tests {
   
   
        runTest(test.goroutines, test.tasks)
    }
}

func runTest(numGoroutines, numTasks int) {
   
   
    counter := &Counter{
   
   }
    var wg sync.WaitGroup
    tasks := make(chan int, numTasks)
    
    // 记录开始时间
    start := time.Now()
    
    // 启动工作协程
    for i := 0; i < numGoroutines; i++ {
   
   
        wg.Add(1)
        go func() {
   
   
            defer wg.Done()
            for task := range tasks {
   
   
                // 模拟工作负载
                heavyWork(task)
                counter.Increment()
            }
        }()
    }
    
    // 发送任务
    for i := 0; i < numTasks; i++ {
   
   
        tasks <- i
    }
    close(tasks)
    
    // 等待所有工作完成
    wg.Wait()
    
    duration := time.Since(start)
    throughput := float64(numTasks) / duration.Seconds()
    
    fmt.Printf("\nTest Results for %d goroutines processing %d tasks:\n", numGoroutines, numTasks)
    fmt.Printf("Total time: %v\n", duration)
    fmt.Printf("Throughput: %.2f tasks/second\n", throughput)
    fmt.Printf("Tasks completed: %d\n", counter.GetCount())
    printMemStats()
}

func heavyWork(n int) {
   
   
    // 模拟CPU密集型操作
    for i := 0; i < 1000; i++ {
   
   
        _ = n * i
    }
    // 模拟IO操作
    time.Sleep(time.Millisecond)
}

func printMemStats() {
   
   
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("Memory usage: %v MB\n", m.Alloc/1024/1024)
}

Java 版本 (ConcurrencyTest.java):

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;

public class ConcurrencyTest {
   
   
    static class Counter {
   
   
        private AtomicLong count = new AtomicLong(0);
        
        public void increment() {
   
   
            count.incrementAndGet();
        }
        
        public long getCount() {
   
   
            return count.get();
        }
    }
    
    public static void main(String[] args) {
   
   
        int[][] tests = {
   
   
            {
   
   100, 10000},
            {
   
   1000, 10000},
            {
   
   5000, 10000},
            {
   
   10000, 10000}
        };
        
        for (int[] test : tests) {
   
   
            runTest(test[0], test[1]);
        }
    }
    
    private static void runTest(int numThreads, int numTasks) {
   
   
        Counter counter = new Counter();
        BlockingQueue<Integer> tasks = new LinkedBlockingQueue<>();
        
        // 创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            numThreads,
            numThreads,
            60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(numTasks),
            new ThreadFactory() {
   
   
                private int count = 0;
                public Thread newThread(Runnable r) {
   
   
                    Thread t = new Thread(r);
                    t.setName("Worker-" + (++count));
                    return t;
                }
            },
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
        
        // 记录开始时间
        long start = System.currentTimeMillis();
        
        // 提交任务
        CompletableFuture<?>[] futures = new CompletableFuture[numTasks];
        for (int i = 0; i < numTasks; i++) {
   
   
            final int task = i;
            futures[i] = CompletableFuture.runAsync(() -> {
   
   
                heavyWork(task);
                counter.increment();
            }, executor);
        }
        
        // 等待所有任务完成
        CompletableFuture.allOf(futures).join();
        
        long duration = System.currentTimeMillis() - start;
        double throughput = numTasks * 1000.0 / duration;
        
        System.out.printf("\nTest Results for %d threads processing %d tasks:\n", 
                         numThreads, numTasks);
        System.out.printf("Total time: %d ms\n", duration);
        System.out.printf("Throughput: %.2f tasks/second\n", throughput);
        System.out.printf(

最低0.47元/天解锁文章