Comment Golang tire parti du multicœur

golang utilise monocœur et monothread par défaut. Vous pouvez définir la prise en charge multicœur et multithread en ajustant ou en définissant les paramètres de fonctionnement

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

<. 🎜>Go démarre à partir de la version 1.5 et adopte par défaut Pour l'exécution multicœur, la valeur par défaut est le nombre de cœurs de votre CPU Dans les versions précédentes, la valeur par défaut était 1

Alors dans quelles circonstances devrait-il le faire. on utilise le multi-core pour accélérer le programme, et dans quelles circonstances peut-on utiliser un seul core ?

Maintenant, nous utilisons un programme simple pour illustrer :

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())}

Ce programme exécute "select sleep(1) as a" dix fois s'il bloque séquentiellement l'exécution, le temps d'exécution le fera certainement. prend plus de 10 secondes, et la coroutine que nous utilisons n'aura pas cette situation.

Nous pouvons modifier "runtime.GOMAXPROCS(1)" pour définir s'il s'agit d'une exécution monocœur ou multicœur.

Pour plus de connaissances sur le golang, veuillez faire attention à la colonne

tutoriel golang.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!