Golang与Java的并发性能对比

白龙马玉龙

已于 2022-08-08 14:22:08 修改

阅读量2.8k

点赞数 1

分类专栏：性能测试文章标签： java 开发语言 golang 性能测试并行编程

于 2022-08-08 14:03:55 首次发布

本文链接：https://blog.csdn.net/yehuijun/article/details/126223686

版权

性能测试专栏收录该内容

5 篇文章 0 订阅

订阅专栏

参考《golang java 对比_golang编程语言和java的性能对比》我们进一步测试Golang和Java的在并发情况下的性能对比

https://blog.csdn.net/weixin_35712223/article/details/114063308

对比测试环境

MacBook Pro, Apple M1 MAX, 10核心（8性能2效能），内存 32G

Golang, go version

go version go1.18.3 darwin/amd64

Java, java -version

java version "11.0.15" 2022-04-19 LTS
Java(TM) SE Runtime Environment 18.9 (build 11.0.15+8-LTS-149)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.15+8-LTS-149, mixed mode)

性能测试代码

Golang 性能测试代码

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	var wg sync.WaitGroup
	start := time.Now().UnixNano()
	maxCount := 100 //调整并行数量， 调整测试规模
	for i := 0; i < maxCount; i++ {
		count := i
		wg.Add(1)
		go func() {
			defer wg.Done()
			value := fibonacci(50) //fibonacci 递归算法；  fibonacciV2 非递归算法
			if count > maxCount-3 {
				fmt.Println(value) //减少不必要的输出， 减少因屏幕输出对测试结果的影响
			}
		}()
	}
	wg.Wait()
	end := time.Now().UnixNano()
	fmt.Printf("Time Consume: %v", (end-start)/1e6)
}

func fibonacci(i int64) int64 {
	if i < 2 {
		return i
	}
	return fibonacci(i-2) + fibonacci(i-1)
}

func fibonacciV2(i int64) int64 {
	if i < 2 {
		return i
	}
	var first, second, result, j int64
	first = 0
	second = 1
	result = 0
	for j = 2; j <= i; j++ {
		result = first + second
		first = second
		second = result
	}
	return result
}

Java性能测试代码

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Hello {

        public  static void main(String[] args){
            long start = System.currentTimeMillis();
            ExecutorService threadPool = Executors.newFixedThreadPool(64);
            int maxCount = 100;
            final CountDownLatch countDownLatch = new CountDownLatch(maxCount);
            List<Thread> workerList = new ArrayList<>();
            for(int i=0;i<maxCount;i++) {
                int count = i;
                threadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        long value = fibonacci(50);
                        if (count>maxCount - 3){
                            System.out.println(value);
                        }
                        countDownLatch.countDown();
                    }
                });
            }
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            threadPool.shutdown();
            long end = System.currentTimeMillis();
            System.out.println("Time Consume: "+(end-start));

        }

        static long fibonacci( long i){
            if(i<2) return i;
            return fibonacci(i-2) + fibonacci(i-1);
        }

        static long fibonacciV2( long i){
            if(i<2) return i;
            long first = 0;
            long second = 1;
            long result = 0;
            for(int j=2;j<=i;j++){
                result = first + second;
                first = second;
                second = result;
            }
            return result;
        }
}