go语言中goroute使用：=遇到的坑

先看下源代码，预想从1至N总取出所有能被a或b整除的正整数之和，为了利用go语言的并行优势，特使用goroute特性来实现，同时使用普通顺序计算进行效率比较分析

package chango

import (
   "fmt"
   "time"
)

func get_sum_of_divisible(num int64, divider int64, resultChan chan int64) {
   var sum int64 = 0
   var value int64
   for value = 1; value < num; value++ {
      if value%divider == 0 {
         sum += value
      }
   }
   resultChan <- sum
}
func Zhengchu_testing(limit int64, one int64, two int64) {  
   resultchan := make(chan int64, 3)
   var three int64
   three = one * two
   
   t_start := time.Now()
  
   go get_sum_of_divisible(limit, one, resultchan)
   go get_sum_of_divisible(limit, two, resultchan)
   go get_sum_of_divisible(limit, three, resultchan)

   one_sum, two_sum, three_sum := <-resultchan, <-resultchan, <-resultchan
  
   var sum int64
   var value int64
   sum = one_sum + two_sum - three_sum

   fmt.Println(sum)
   t_end := time.Now()
   fmt.Println(one_sum, two_sum, three_sum)
   fmt.Printf("testing times1:%v
", t_end.Sub(t_start))

   sum = 0
   t_start = time.Now()

   for value = 1; value < limit; value++ {
      if value%one == 0 {
         sum += value

      }
      if value%two == 0 {
         sum += value
      }
      if value%three == 0 {
         sum -= value
      }
   }
   fmt.Println(sum)
   t_end = time.Now()
   fmt.Printf("testing times2:%v
", t_end.Sub(t_start))
}
然后在main包中调用该chango包
package main

import "./chango"

func main(){

  chango.Zhengchu_testing(10,3,5)

}

初看上去，chango包没有语法毛病，但是实际测试发现，显然通过顺序计算10以内能被3或5整除的所有正整数分别为3，5，6，9，他们之和应该为23，能被3整数的整数之和为3+6+9=18，能被5整除的正整数之和为5，能被3*15=15的正整数之和为0
而通过goroute计算10以内能被3或5整除的所有正整数之和却不是23，而是-13或13，这又是为什么呢？
通过调试发现，问题就出现在“：=”语句中

  one_sum, two_sum, three_sum := <-resultchan, <-resultchan, <-resultchan

多次运行

通过分别打印能被3或5或3*5=15的正整数之和，他们的结果竟然是0，18，5或0，5，18，这个结果竟然不唯一


既然是这个语句有问题，此路不通，暂时绕道行之

于是修改源代码如下：

package chango

import (
   "fmt"
   "time"
)

func get_sum_of_divisible(num int64, divider int64, resultChan chan int64) {
   var sum int64 = 0
   var value int64
   for value = 1; value < num; value++ {
      if value%divider == 0 {
         sum += value
      }
   }
   resultChan <- sum
}
func Zhenchu_testing(limit int64, one int64, two int64) {  

   var three int64
   three = one * two

numbers:=[3]int64{one,two,three}
  
   var ch [3](chan int64)
   for i := 0; i < 3; i++ {
      ch[i] = make(chan int64)
   }
   t_start := time.Now()
   for i:=0;i<3;i++{
      go get_sum_of_divisible(limit, numbers[i], ch[i])
   }
   
   one_sum:=<-ch[0]
   two_sum:=<-ch[1]
   three_sum:=<-ch[2]
   var sum int64
   var value int64
   sum = one_sum + two_sum - three_sum

   fmt.Println(sum)
   t_end := time.Now()
   fmt.Println(one_sum, two_sum, three_sum)
   fmt.Printf("testing times1:%v
", t_end.Sub(t_start))

   sum = 0
   t_start = time.Now()

   for value = 1; value < limit; value++ {
      if value%one == 0 {
         sum += value

      }
      if value%two == 0 {
         sum += value
      }
      if value%three == 0 {
         sum -= value
      }

   }
   fmt.Println(sum)
   t_end = time.Now()
   fmt.Printf("testing times2:%v
", t_end.Sub(t_start))
}

这下在main包中调用该chango包通过！

结下来分析goroute同普通顺序计算进行效率比较分析，开始当计算从1至N总取出所有能被a或b整除的正整数之和中N的N的数值比较小的情况下，goroute的并行出来优势没有发挥出来，

测试打印输出如下：
当N=20

  78 
  63 30 15
  testing times1:33.557µs
  78
  testing times2:2.382µs

当N的数值很大的情况下，如100000000，goroute的并行计算优势就发挥出来了！

  测试打印输出如下：
  2333333316666668
  1666666683333333 999999950000000 333333316666665
  testing times1:1.574445477s
  2333333316666668
  testing times2:2.199982414s

---

参考学习资料