前言

之前学习过程中写的一些工具几乎都是单线程跑,一个程序跑下来很费时间,故而学习了并发并行。

并发

程序中的多个线程在同一CPU单核下被CPU时间片的分配管理。

假设存在三个线程A、B、C。

线程A运行到一半的时候,CPU分配的时间片到期(CPU保存当前线程A的上下文),就会强行执行其他的线程(其他线程同理)。

并行

程序中的多个线程在多个CPU的多个核心下运行。

假设存在三个线程A、B、C。

线程A运行在CPU的第一个线程上,同时线程B运行在CPU的第二个线程上(线程C同理)。

程序

单线程(默认使用CPU一个核心)

package main

import (
    "time"
    "fmt"
)

func main() {
    start := time.Now()
    for i:=0;i<100000000;i++ {
        fmt.Println(i)
    }
    fmt.Println(time.Now().Sub(start))
}

多线程(由runtime.GOMAXPROCS(num)指定)

package main

import (
    "fmt"
    "runtime"
    "strconv"
    "sync"
    "time"
)

var wait sync.WaitGroup
func main() {
    start := time.Now()
    runtime.GOMAXPROCS(runtime.NumCPU()/4 * 3)
    var test int64 = 100000000
    ch := make(chan int64,1000)
    var i int64 = 0
    for ;i<test;i += 100000 {
        wait.Add(1)
        go Factory(i,ch)
    }
    wait.Wait()
    fmt.Println(time.Now().Sub(start))
}

func Factory(input int64, ch chan int64) {
    var i int64 = input
    for ;i<input + 100000;i++ {
        fmt.Println(i)
    }
    wait.Done()
}

对比结果

  1. 单线程

    upload successful

  2. 多线程

    upload successful

时间上两者耗时差不多,这是为啥?

打印函数的耗时

package main

import (
    "time"
    "fmt"
)

func main() {
    start := time.Now()
    for i:=0;i<100000000;i++ {
        //fmt.Println(i)
    }
    fmt.Println(time.Now().Sub(start))
}

upload successful

虽然单线程和多线程所用的CPU线程数量是有很大差别的,但是整体的程序调用Println函数的次数是相同的(浅显的理解)。

再次运行多线程

  1. CPU单线程

upload successful

  1. CPU2线程

upload successful

  1. CPU3线程

upload successful

  1. CPU4线程

upload successful

可见,随着CPU线程数的增多,消耗的时间也在慢慢减少。

CPU线程数设置多少合适?

经测试,在多台机器下,CPU线程数设置为CPU总线程数的四分之三即可。



golang      golang

本博客所有文章除特别声明外,均采用 CC BY-SA 3.0协议 。转载请注明出处!