Golang 效率初（粗）测

2026-06-01 4 花语

本文内容纲要：

从接触Golang开始，断断续续已有差不多一年左右的时间了，都是业余自己学学看看，尚主要限于语法及语言特性，还没有用它写过实际的项目。

关于Golang的语法及语言特性，网上有很多资源可以学习。后面某个时间，我也许会写一篇粗浅的文章，来比较一下Golang和C++、Delphi甚至C#等语言语法方面的特性。

我算是个急性子的人（当然现在好一些了），于是作为码农，显而易见会对“效率”比较敏感。这里的效率不单单指编译器生成的机器码优化程度，也包括编译器的编译速度，所以我对C++兴趣不算大，虽然它是我平时的工作语言。

言归正传。

分别用Golang、C++、Delphi写了四个小例子，包括普通的应用场景、字符串（串接）操作及数据密集计算（当然也会涉及到譬如库函数的优化等）。我的电脑软硬件环境为：Win764bit，XeonE3-1230（8核），16GRAM。Golang版本是1.3.1Windows/386，VC则用的VS2012，而Delphi则用的XE6Update1。VC和Delphi编译设置为Win32&Release，Golang则使用默认配置。

所有测试计量单位均为毫秒（ms）。

首先是计算π的例子，代码分别如下。

Golang：

packagemain import( "fmt" "time" ) constcNumMax=999999999 funcmain(){ sign:=1.0 pi:=0.0 t1:=time.Now() fori:=1;i<cNumMax+2;i+=2{ pi+=(1.0/float64(i))*sign sign=-sign } pi*=4 t2:=time.Now() fmt.Printf("PI=%f;Time=%d\n",pi,t2.Sub(t1)/time.Millisecond) } C++： #include"stdafx.h" #include<stdio.h> #include<time.h> int_tmain(intargc,_TCHAR*argv[]) { constintcNumMax=999999999; doublesign=1.0; doublepi=0; clock_tt1=clock(); for(inti=1;i<cNumMax+2;i+=2) { pi+=(1.0f/(double)i)*sign; sign=-sign; } pi*=4; clock_tt2=clock(); printf("PI=%lf;Time=%d\n",pi,t2-t1); return0; }

Delphi：

programPiCalcer; {$APPTYPECONSOLE} {$R*.res} uses System.SysUtils,System.DateUtils; const cNumMax=999999999; var Sign:Double=1.0; Pi:Double=0.0; I:Integer; T1:Double; T2:Double; S:string; begin T1:=Now; I:=1; whileI<cNumMax+2do begin Pi:=Pi+(1.0/I)*Sign; Sign:=-Sign; I:=I+2; end; Pi:=Pi*4; T2:=Now; S:=Format(PI=%.6f;Time=%d,[Pi,MilliSecondsBetween(T2,T1)]); Writeln(S); Readln; end.

分别执行10次，结果如下。

Golang：2038202820362024203420152034201820242018，平均：2026.9；

C++：2041205220622036203320492039202620372038，平均：2041.3；

Delphi：2594257225742584257425642575257525712563，平均：2574.6。

结果居然很不错，比VC还快，而Delphi，大家都懂，优化向来不是它的“强项”。

然后是个质数生成例子。

Golang：

packagemain import( "fmt" "time" ) constcNumMax=10000000 funcmain(){ t1:=time.Now() varnums[cNumMax+1]int vari,jint fori=2;i<cNumMax+1;i++{ nums[i]=i } fori=2;i<cNumMax+1;i++{ j=2 forj*i<cNumMax+1{ nums[j*i]=0 j++ } } cnt:=0 fori=2;i<cNumMax+1;i++{ ifnums[i]!=0{ cnt++ } } t2:=time.Now() fmt.Println("Time:",t2.Sub(t1),"Count:",cnt) } C++： #include"stdafx.h" #include<stdlib.h> #include<time.h> constintcNumMax=10000000; int_tmain(intargc,_TCHAR*argv[]) { clock_tt1=clock(); int*nums=(int*)malloc(sizeof(int)*(cNumMax+1)); inti; for(i=2;i<cNumMax+1;i++) { nums[i]=i; } intj; for(i=2;i<cNumMax+1;i++) { j=2; while(j*i<cNumMax+1) { nums[j*i]=0; j++; } } intcnt=0; for(i=2;i<cNumMax+1;i++) { if(nums[i]!=0) { cnt++; } } free(nums); clock_tt2=clock(); printf("Time:%dms;Count:%d\n",t2-t1,cnt); }

Delphi：

programPrimeSieve; {$APPTYPECONSOLE} {$R*.res} uses System.SysUtils,System.DateUtils; const cNumMax=10000000; var T1,T2:Double; I,J:Integer; Cnt:Integer; Nums:arrayofInteger; begin T1:=Now; SetLength(Nums,cNumMax+1); forI:=2tocNumMaxdo Nums[I]:=I; forI:=2tocNumMaxdo begin J:=2; whileJ*I<cNumMax+1do begin Nums[J*I]:=0; Inc(J); end; end; Cnt:=0; forI:=2tocNumMaxdo begin ifNums[I]<>0then Inc(Cnt); end; SetLength(Nums,0); T2:=Now; Writeln(Format(Cnt=%d;Time=%d,[Cnt,MilliSecondsBetween(T2,T1)])); Readln; end.

同样分别执行10次，结果如下。

Golang：959957959953961951948956956956，平均：955.6；

C++：965965967953961964963960956956，平均：961；

Delphi：973976973982981970977979971977，平均：975.9；

仍然，Golang看上去最快，而Delphi则很正常地居末。

所以我忍不住想要来一个能展现Delphi优点的例子，这个例子几乎毫无疑问，和字符串操作（及内存管理器）相关，所以有如下字符串串接的示例（其中涉及到了譬如IntToStr/itoa这样的函数调用，我自己实现了个C++版的IntToStr）。

Golang：

packagemain import( "bytes" "fmt" "strconv" "time" ) constcNumMax=1000000 //bytes.Buffer(7.2.6) functestViaBuffer()string{ varbufbytes.Buffer fori:=0;i<cNumMax;i++{ buf.WriteString(strconv.Itoa(i)) } returnbuf.String() } //+= functestViaNormal()string{ varretstring fori:=0;i<cNumMax;i++{ ret+=strconv.Itoa(i) } returnret } funcmain(){ fmt.Println("Testviabytes.Buffer...") t1:=time.Now() s:=testViaBuffer() t2:=time.Now() fmt.Printf("Result:%s...(Length=%d);Time:%dms\n",s[2000:2005],len(s),t2.Sub(t1)/time.Millisecond) /* fmt.Println("Testvianormalway...") t1=time.Now() s=testViaNormal() t2=time.Now() fmt.Printf("Result:%s...(Length=%d);Time:%dms\n",s[2000:2005],len(s),t2.Sub(t1)/time.Millisecond) */ } C++： #include"stdafx.h" #include<time.h> #include<stdarg.h> #include<string> #include<iostream> usingnamespacestd; constintcNumMax=1000000; wstringFormatV(constwchar_t*pwcFormat,va_listargList) { wstringws; intnLen=_vscwprintf(pwcFormat,argList); if(nLen>0) { ws.resize(nLen); vswprintf_s(&ws[0],nLen+1,pwcFormat,argList); } returnws; } wstring__cdeclFormat(constwchar_t*pwcFormat,...) { va_listargList; va_start(argList,pwcFormat); wstringws=FormatV(pwcFormat,argList); va_end(argList); returnws; } stringFormatVA(constchar*pcFormat,va_listargList) { strings; intnLen=_vscprintf(pcFormat,argList); if(nLen>0) { s.resize(nLen); vsprintf_s(&s[0],nLen+1,pcFormat,argList); } returns; } string__cdeclFormatA(constchar*pcFormat,...) { va_listargList; va_start(argList,pcFormat); strings=FormatVA(pcFormat,argList); va_end(argList); returns; } wstringIntToStr(intnValue) { returnFormat(L"%d",nValue); } stringIntToStrA(intnValue) { returnFormatA("%d",nValue); } wstringtestW() { wstringret=L""; for(inti=0;i<cNumMax;i++) { ret+=IntToStr(i); } returnret; } stringtest() { stringret=""; for(inti=0;i<cNumMax;i++) { ret+=IntToStrA(i); } returnret; } int_tmain(intargc,_TCHAR*argv[]) { cout<<"Startingtestwithaloopnumof"<<cNumMax<<endl; clock_tt1=clock(); strings=test(); clock_tt2=clock(); cout<<"Result:"<<s.substr(2000,5)<<"..."<<";Size:"<<s.size()<<";Time:"<<t2-t1<<"ms"<<endl; cout<<endl; cout<<"StartingtestforWSTRINGwithaloopnumof"<<cNumMax<<endl; t1=clock(); wstringws=testW(); t2=clock(); wcout<<"Result:"<<ws.substr(2000,5)<<"..."<<";Size:"<<ws.size()<<";Time:"<<t2-t1<<"ms"<<endl; return0; }

Delphi：

programStrPerformanceTest; {$APPTYPECONSOLE} {$R*.res} uses System.SysUtils,System.DateUtils; const cNumMax=1000000; functionTestViaStringBuilder:string; var SB:TStringBuilder; I:Integer; begin SB:=TStringBuilder.Create; forI:=0tocNumMax-1do SB.Append(IntToStr(I)); Result:=SB.ToString; FreeAndNil(SB); end; functionTestViaNormal:string; var I:Integer; begin Result:=; forI:=0tocNumMax-1do Result:=Result+IntToStr(I); end; var T1:Double; T2:Double; S:string; begin Writeln(Startingtestwithaloopnumof,cNumMax,...); T1:=Now; S:=TestViaStringBuilder; T2:=Now; Writeln(Format(TestviaTStringBuilderresult:%s...(Length=%d);Time:%dms,[Copy(S,2001,5),Length(S),MilliSecondsBetween(T2,T1)])); T1:=Now; S:=TestViaNormal; T2:=Now; Writeln(Format(Testvianormal-way(+=)result:%s...(Length=%d);Time:%dms,[Copy(S,2001,5),Length(S),MilliSecondsBetween(T2,T1)])); Readln; end.

分别执行10次。悲剧的是，Golang里的字符串+=操作实在太慢了，我实在不想等下去，所以只给出了其官方推荐的使用bytes.Buffer的结果。而在这个例子中，Delphi使用TStringBuilder并未显示出什么优化（FastMM实在太强悍了！），所以我也只给出了普通的串接结果（AnsiString和string都是Delphi的原生类型，有着类同的内存布局，效率上应没有什么差别，所以这里只测试了string）。

Golang：141148134119133123145127122132，平均：132.4；

C++（std::string）：384400384385389391389384390383，平均：387.9；

C++（std::wstring）：519521522521519522518519518518，平均：519.7；

Delphi（string）：41414141414141414441，平均：41.3；

果然，Delphi大幅领先，当然这主要归功于FastMM，这个开源的Pascal家族的内存管理器实在太强大了！

当然这个测试对C++并不公平，因为Golang的写法并非普通的串接，只是我不知道STL或Boost里有无类似StringBuilder这样的利器呢？

最后是个数据密集计算型的例子。

Golang：

packagemain import( "fmt" "time" ) constcSizeint=30 typemymatrix[cSize][cSize]int funcmkmatrix(rows,colsint,mx*mymatrix){ rows-- cols-- count:=1 forr:=0;r<=rows;r++{ forc:=0;c<=cols;c++{ mx[r][c]=count count++ } } } funcmultmatrix(rows,colsint,m1,m2*mymatrix,mm*mymatrix){ rows-- cols-- fori:=0;i<=rows;i++{ forj:=0;j<=cols;j++{ val:=0 fork:=0;k<=cols;k++{ val+=m1[i][k]*m2[k][j] mm[i][j]=val } } } } funcmain(){ varm1,m2,mmmymatrix mkmatrix(cSize,cSize,&m1) mkmatrix(cSize,cSize,&m2) t0:=time.Now() fori:=0;i<=100000;i++{ multmatrix(cSize,cSize,&m1,&m2,&mm) } t:=time.Since(t0) fmt.Println(mm[0][0],mm[2][3],mm[3][2],mm[4][4],mm[29][29]) fmt.Println("tick=",t) } C++： #include"stdafx.h" #include<time.h> #include<iostream> usingnamespacestd; constintMATRIX_SIZE=30; intMatrix[MATRIX_SIZE][MATRIX_SIZE]; voidMakeMatrix(introws,intcols,intmx[MATRIX_SIZE][MATRIX_SIZE]) { rows--; cols--; intcount=1; for(intr=0;r<=rows;r++) { for(intc=0;c<=cols;c++) { mx[r][c]=count; count++; } } } voidMatrixMult(introws,intcols,constintm1[MATRIX_SIZE][MATRIX_SIZE],constintm2[MATRIX_SIZE][MATRIX_SIZE],intmx[MATRIX_SIZE][MATRIX_SIZE]) { rows--; cols--; intval; for(inti=0;i<=rows;i++) { for(intj=0;j<=cols;j++) { val=0; for(intk=0;k<=cols;k++) { val+=m1[i][k]*m2[k][j]; mx[i][j]=val; } } } } int_tmain(intargc,_TCHAR*argv[]) { intnum=100000; intm1[MATRIX_SIZE][MATRIX_SIZE],m2[MATRIX_SIZE][MATRIX_SIZE],mx[MATRIX_SIZE][MATRIX_SIZE]; MakeMatrix(MATRIX_SIZE,MATRIX_SIZE,m1); MakeMatrix(MATRIX_SIZE,MATRIX_SIZE,m2); clock_tt1=clock(); for(inti=0;i<=num;i++) { MatrixMult(MATRIX_SIZE,MATRIX_SIZE,m1,m2,mx); } clock_tt2=clock(); cout<<mx[0][0]<<""<<mx[2][3]<<""<<mx[3][2]<<""<<mx[4][4]<<endl; cout<<t2-t1<<"ms"<<endl; return0; }

Delphi：

programProject1; {$APPTYPECONSOLE} {$R*.res} uses System.SysUtils,System.DateUtils; const cSize=30; type TMatrix=array[0..cSize-1,0..cSize-1]ofInteger; procedureMakeMatrix(Rows,Cols:Integer;varMx:TMatrix); var R,C,Count:Integer; begin Dec(Rows); Dec(Cols); Count:=1; forR:=0toRowsdo forC:=0toColsdo begin Mx[R,C]:=Count; Inc(Count); end; end; procedureMatrixMult(Rows,Cols:Integer;constM1,M2:TMatrix;varMx:TMatrix);inline; var I,J,K,Val:Integer; begin Dec(Rows); Dec(Cols); forI:=0toRowsdo forJ:=0toColsdo begin Val:=0; forK:=0toColsdo Inc(Val,M1[I,K]*M2[K,J]); Mx[I,J]:=Val; end; end; var Num,I:Integer; M1,M2,Mx:TMatrix; T1,T2:Double; begin Num:=100000; MakeMatrix(cSize,cSize,M1); MakeMatrix(cSize,cSize,M2); T1:=Now; forI:=0toNumdo MatrixMult(cSize,cSize,M1,M2,Mx); T2:=Now; WriteLn(Mx[0,0],,Mx[2,3],,Mx[3,2],,Mx[4,4],,mx[29,29]); WriteLn(C=,MilliSecondsBetween(T2,T1),ms); end.

分别执行10次后结果如下。

Golang：8757879087138748873787448752875287468754，平均：8749.3；

C++：1723173517141707171317251708172317201725，平均：1719.3；

Delphi：2384236223592389236223512340235223562352，平均：2360.7；

在这样的密集运算例子里，Golang的表现实在很差，Golang的编译器优化还有很长的路。而Delphi则不出意外，不温不火，勉强也还算能接受吧。

至此，或许大致可以这样初步评断，Golang在大部分应用场景下在效率方面是满足要求的，而若涉及到密集运算，当前比较好的方法应该是要通过CGo了。考虑到Golang强大的goroutine和channel、丰富的标准库（譬如网络方面）、精简的语法和非常快速的编译速度（几乎媲美Delphi），后端开发尝试下Golang应是比较可行的，而也确实有不少早已用Golang作后端开发的项目实例了。

注：关于Golang的语言语法及并发方面的特性，过段时间再浅叙。

经由Colin同学建议，测试字符串串接中使用的自实现版IntToStr效率不行，对C++很不公平，于是我用回了_itoa_s和_itow_s这俩库函数，如下：

#include"stdafx.h" #include<time.h> #include<stdarg.h> #include<string> #include<iostream> usingnamespacestd; constintcNumMax=1000000; wstringtestW() { wstringret=L""; wchar_tws[10]; for(inti=0;i<cNumMax;i++) { _itow_s(i,ws,10); ret+=ws; } returnret; } stringtest() { stringret=""; chars[10]; for(inti=0;i<cNumMax;i++) { _itoa_s(i,s,10); ret+=s; } returnret; } int_tmain(intargc,_TCHAR*argv[]) { cout<<"Startingtestwithaloopnumof"<<cNumMax<<endl; clock_tt1=clock(); strings=test(); clock_tt2=clock(); cout<<"Result:"<<s.substr(2000,5)<<"..."<<";Size:"<<s.size()<<";Time:"<<t2-t1<<"ms"<<endl; cout<<endl; cout<<"StartingtestforWSTRINGwithaloopnumof"<<cNumMax<<endl; t1=clock(); wstringws=testW(); t2=clock(); wcout<<"Result:"<<ws.substr(2000,5)<<"..."<<";Size:"<<ws.size()<<";Time:"<<t2-t1<<"ms"<<endl; return0; }

测试10次，效率果然大幅提升，平均大约分别是：std::string-70ms、std::wstring-75ms，相当快速！不过还是比Delphi慢了40%左右。

本文内容总结：

原文链接：https://www.cnblogs.com/ecofast/p/4043873.html