golang语言中的math库中效率低下,可能是类型转换花费了大量时间?

原创
2017/10/26 05:25
阅读数 2.3K

今天写了个加密的东西,用到了math.Sqrt求质数,发现用的时间很久,先不管下面的例子算法是否有问题,我就写了个demo寻找10 000 000以内的质数个数,原本这个demo是delphi写的,我把它翻译成其他语言,于是我测试了下几个语言的效率:

先用Go语言翻译了下代码:

func main() {
	t := time.Now()
	sum := 0

	for i := 0; i <= 10000000; i++ {
		if isPrime(i) == true {
			sum = sum + 1

		}
	}
	fmt.Println(sum)
	fmt.Println(time.Now().Sub(t))
}
func isPrime(n int) bool {

	end := int(math.Sqrt(float64(n)))
	for i := 2; i <= end; i++ {
		if n%i == 0 {
			return false
			
		}
	}
	return true
}

上面的GO语言输出结果:

664581

40.5965203s

用了40秒左右。

 

然后我再用网上抄的delphi的这个demo执行了下:

function isPrime(number: integer): boolean;
var
  iHalf,iCount:integer;
begin
   result:=true;
   iHalf:=Round(SQRT(number));
   for iCount:=2 to iHalf do
   begin
     if (number mod iCount)=0 then
     begin
       result:=false;
       break;
     end;
   end;
end;
procedure TForm1.Button1Click(Sender: TObject);
var i ,sum:integer;
var m:TDateTime;
begin
 m:=((Now))    ;
 sum:=0;
 for i:=0  To 10000000 do
 begin
    if isPrime(i)=True then
    begin
     sum:=sum+1;
    end;
 end;
 Memo1.Lines.Add(TimeToStr(Now-m))    ;
 Memo1.Lines.Add(IntToStr(sum))

end;

最终执行结果:

0:00:12
664581
delphi 只用了12秒钟,我感到奇怪,GO语言的执行效率应该快于delphi的啊?

 

我再用JAVA再次翻译了下:

public class fdfd {
	public static void main(String[] args) {
		long t = (System.currentTimeMillis());
		int sum = 0;

		for (int i = 0; i <= 10000000; i++) {
			if (isPrime(i)) {
				sum = sum + 1;
			}

		}
		System.out.println(sum);
		System.out.println((float) (System.currentTimeMillis() - t) / 1000);
	}

	public static boolean isPrime(int n) {
		int end = (int) Math.sqrt(n);
		for (int i = 2; i <= end; i++) {
			if (n % i == 0)
				return false;
		}
		return true;
	}

 

执行结果:

664581
16.632

JAVA只有了16秒钟。

我用python再次翻译了下

def isPrime(n):
    result = True
    end = int(math.sqrt(n) + 1)
    for i in range(2, end):
        if n % i == 0:
            result = False
            
    return result

sumC = 0
t = (time.time())
for i in range(10000000):
    if isPrime(i):
        sumC = sumC + 1

print(sumC)
print((time.time() - t))

发现python很久没有结果,这个也是可以想得到的,毕竟是脚本语言,比不上解释型的语言和编译型的语言。

同时用C#编写了下,大致代码如下

void Button1Click(object sender, EventArgs e)
        {     int sum=0;
              TimeSpan ts1 = new TimeSpan(DateTime.Now.Ticks);
              for (int i=0;i<=10000000;i++){
                  if (isPrime(i)==true) {
                  sum=sum+1;
                }
              }
            TimeSpan ts2 = new TimeSpan(DateTime.Now.Ticks);
            TimeSpan ts3 = ts1.Subtract(ts2).Duration();
            textBox1.Text=sum.ToString()+"\r\n";
            textBox1.Text=textBox1.Text+ts3.ToString();
        }
        bool isPrime(int n) {
            int end= (int) Math.Sqrt(n);
            for (int i=2;i<=end;i++){
                if (n % i==0){
                    return false;
                      
                }
            }
            return true;
        }
    }

在net3.5下,c#的最终执行效果: 

664581
00:00:16.9267274

16秒,大致和JAVA相当。

 

按道理来说,GO语言中math.sqrt算法上不会和其他语言相差太多的啊,为什么执行效率差别这么大?因此只能猜测可能GO语言类型转换浪费了大量的时间。


 

展开阅读全文
打赏
0
1 收藏
分享
加载中
i3 g2030 win7 用楼主的代码只用了6秒
2017/10/28 14:25
回复
举报
用楼主的代码,我这只用了6秒
2017/10/28 14:23
回复
举报
pprofile 分析一下cpu就知道了
2017/10/28 07:27
回复
举报
改成32位int 和java一样快 老铁
2017/10/27 20:20
回复
举报
你这是在炫耀吗
2017/10/27 14:24
回复
举报
你的写法不太符合Go的思想。
package main

import (
  "fmt"
)

func generate(ch chan<- int) {
  for i := 2; ; i++ {
    ch <- i // Send 'i' to channel 'ch'.
  }
}

func filter(src <-chan int, dst chan<- int, prime int) {
  for i := range src { // Loop over values received from 'src'.
    if i%prime != 0 {
      dst <- i // Send 'i' to channel 'dst'.
    }
  }
}

func sieve() {
  ch := make(chan int) // Create a new channel.
  go generate(ch) // Start generate() as a subprocess.
  var iCount int32
  for {
    prime := <-ch
    fmt.Print(prime, "\n")
    ch1 := make(chan int)
    go filter(ch, ch1, prime)
    ch = ch1
    if iCount > 9999 {
      break
    }
    iCount++
  }
}

func main() {
  sieve()
}


这个才是Go思想的写法
2017/10/26 17:51
回复
举报
golang 1.7.3 要16s
2017/10/26 17:06
回复
举报
I7 window10 golang 1.9

22秒,使用int32 代替 int 后 9.4秒

难道我使用的是假的 I7 ?
2017/10/26 16:49
回复
举报
cpu 和 内存,go的版本和系统的版本也不说,这样不严谨
2017/10/26 16:35
回复
举报

引用来自“OSC_Pdhdcl”的评论

仔细看看你java实现的类型定义,
确实,把类型换成double慢得不要不要的
2017/10/26 12:26
回复
举报
更多评论
打赏
14 评论
1 收藏
0
分享
返回顶部
顶部