25 goroutine channel实现并发和并行（二）

为什么要使用goroutine

打印1-100000之间的素数（为了延长程序的执行时间，不采用开方的算法）

1. 传统方法，通过for循环遍历各个数
2. 使用并发或并行，将统计素数的任务分配给多个goroutine去完成
3. goroutine结合channel

func main() {
    fmt.Println("开始")
    start := time.Now().Unix()
    for num := 2; num < 100000; num ++ {
        var flag = true
        for i := 2; i < num; i++ {
            if num % i == 0 {
                flag = false
                break
            }
        }
        if flag {
            //fmt.Println(num,"是素数")
        }
    }
    end := time.Now().Unix()
    fmt.Println(end - start)//3(秒)
}

• 写到这里，突发奇想，笔者试了一下自己最喜欢的JavaScirpt计算它需要多久，来一场JS和Golang的大比拼，结果万万没想到

var start = new Date().getTime()
for (num = 2; num < 100000; num++) {
    var flag = true
    for (i = 2; i < num; i++) {
        if (num % i == 0) {
            flag = false
            break
        }
    }
    if (flag) {
        //fmt.Println(num,"是素数")
    }
}
var end = new Date().getTime()
console.log('end-start', end-start)//1332

身为单线程脚本语言的js，竟然比没有使用goroutine的golang还快，为了实现反超，我们使用一下goruntine开启四个协程

var wg  sync.WaitGroup
/*
1 协程 1-25000
2 协程 25001-50000
3 协程 50001-75000
4 协程 75001-100000
start = (n - 1) * 25000
end = n * 25000
 */
func test(n int) {
    for num := (n-1)*25000 + 1; num < n*25000; num++ {
        if num > 1 {
            var flag = true
            for i := 2; i < num; i++ {
                if num%i == 0 {
                    flag = false
                    break
                }
            }
            if flag {
                //fmt.Println(num, "是素数")
            }
        }
    }
    wg.Done()
}

func main() {
    start := time.Now().UnixNano()
    for i := 1; i <= 4; i++ {
        wg.Add(1)
        go test(i)
    }
    wg.Wait()
    end := time.Now().UnixNano()
    fmt.Println("执行完毕", (end-start)/1e6)//执行完毕 1273ms
}

开启四个协程之后，运行计算时间基本持平，不得不赞叹一下，Chrome的V8引擎的确不赖~~~