2020-06-01：百万级int数据量的一个array求和。

福哥答案2020-06-01：

fork/join。

对于百万级长度的数组求和，单线程和多线程下区别不大。
对于千万级长度的数组求和，多线程明显变快，大概是单线程的2-3倍。

go语言测试代码如下：

package test18_sum100w
 
import (
    "fmt"
    "math/rand"
    "testing"
    "time"
)
 
const (
    ARRLEN = 100_0000
)
 
var arr []int
 
func init() {
    arr = make([]int, ARRLEN)
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < ARRLEN; i++ {
        arr[i] = rand.Intn(10_0000_0000)
    }
    fmt.Println("初始化完成")
}
func TestAA(t *testing.T) {
 
}
func TestMutiThreadsToSum(t *testing.T) {
    fmt.Println("多线程开始")
    now := time.Now()
    sum := 0
    const MAXGE = 10000
    const MAXHANG = 100
    ch := make(chan int, MAXHANG)
    f := func(i int) {
        sumtemp := 0
        for j := 0; j < MAXGE; j++ {
            sumtemp += arr[i*MAXGE+j]
        }
        ch <- sumtemp
 
    }
    for i := 0; i < MAXHANG; i++ {
        go f(i)
    }
    for i := 0; i < MAXHANG; i++ {
        sum += <-ch
    }
    fmt.Println(sum)
    fmt.Println("多线程结束", time.Now().Sub(now))
}
 
//go test -v -test.run TestSingleThreadToSum
//go test -bench=. -test.run TestSingleThreadToSum
//go test -v -cover -run TestSingleThreadToSum
func TestSingleThreadToSum(t *testing.T) {
    fmt.Println("单线程开始")
    now := time.Now()
    sum := 0
    for i := 0; i < ARRLEN; i++ {
        sum += arr[i]
    }
    fmt.Println(sum)
    fmt.Println("单线程结束", time.Now().Sub(now))
}

敲命令go test -v：

改下代码，将100万数组改成1000万。测试结果如下：
ARRLEN = 1000_0000
const MAXHANG = 1000