How golang takes advantage of multi-core

Golang uses single-core and single-thread by default. You can set multi-core and multi-thread support by adjusting or setting operating parameters.

runtime.GOMAXPROCS(int)
runtime.GOMAXPROCS(runtime.NumCPU())
直接设置环境变量$GOMAXPROCS

Go starts from version 1.5 and adopts by default For multi-core execution, the default is the number of your CPU cores. In previous versions, the default was 1

. So under what circumstances should we use multi-core to accelerate the program, and under what circumstances can we use a single core? ?

Now we use a simple program to illustrate:

package mainimport (
        "runtime"
        "fmt"
        "sync"
        "database/sql"
        _ "github.com/go-sql-driver/mysql"
	"time")//定义任务队列var waitgroup sync.WaitGroupfunc xtgxiso(num int) {
        //fmt.Println(num)
        db, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/test?charset=utf8")
        if err != nil {
                fmt.Println(err)
        }
        defer db.Close()
        rows, err := db.Query("select sleep(1) as a")
        if err != nil {
                fmt.Println(err)
        }
        defer rows.Close()
        var a string
        for rows.Next() {
                err = rows.Scan(&a)
                if err != nil {
                        fmt.Println(err)
                } else {
                        //fmt.Println(a)
                }
        }
        waitgroup.Done() //任务完成，将任务队列中的任务数量-1，其实.Done就是.Add(-1)}func main() {
	//记录开始时间
	start := time.Now()
        //设置最大的可同时使用的CPU核数和实际cpu核数一致
        runtime.GOMAXPROCS(1)
        for i := 1; i <= 10; i++ {
                waitgroup.Add(1) //每创建一个goroutine，就把任务队列中任务的数量+1
                go xtgxiso(i)
        }
        waitgroup.Wait() //Wait()这里会发生阻塞，直到队列中所有的任务结束就会解除阻塞
	//记录结束时间
	end :=  time.Now()
	//输出执行时间，单位为秒。
	fmt.Println(end.Sub(start).Seconds())}

This program is executed ten times "select sleep(1) as a". If it is sequentially blocking execution, the execution time will definitely It takes more than 10 seconds, and the coroutine we use will not have this situation. We can modify "runtime.GOMAXPROCS(1)" to set whether it is single-core or multi-core execution.

For more golang knowledge, please pay attention to the golang tutorial column.

The above is the detailed content of How golang takes advantage of multi-core. For more information, please follow other related articles on the PHP Chinese website!