Ein Artikel, der Sie in die Grundlagen der Parallelität der Go-Sprache einführt

Einführung

Go-Sprache, eine Sprache, die speziell für Parallelität entwickelt wurde, kostet jedes Mal, wenn Sie einen Microthread starten ungefähr , um eines zu erstellen 2KB2KB起步

假设一个内存条大小4G，一个微线程2kb，1G=1024M=1048576kb，1048576/2=524288，五十多万个

但是你知道像Java，Python等语言，一个线程代价多大吗???，2MB起步，代价直接翻了千倍

所以，激动吧，随便用Go写一个web程序，基本都相当于NginxErste Schritte

🎜

🎜Nehmen Sie eine Speicherstickgröße an🎜🎜🎜4G🎜🎜🎜, a micro-thread🎜🎜 🎜2kb🎜🎜🎜, 🎜🎜 1G=1024M=1048576kb 🎜🎜, 🎜🎜1048576/2= 524288🎜🎜, mehr als eine halbe Million 🎜🎜

🎜Aber wissen Sie, wie viel ein Thread in Sprachen wie Java, Python und anderen Sprachen kostet???,🎜🎜2MB🎜🎜Anfangs hat sich der Preis direkt tausendfach verdoppelt🎜🎜

🎜Also, seien Sie gespannt, schreiben Sie einfach ein Webprogramm in Go, es entspricht im Grunde 🎜🎜 Nginx🎜🎜

<br><br>

goroutine

Go中的微线程，也叫做goroutine，goroutine是并行处理任务的

就像我用两只手同时操作两个手机打游戏一样

而不是一个手玩玩这个，一个手玩玩那个，这样切换式玩法

goroutine由Go的runtime完成调度，goroutinegoroutine

Go中的微线程，也叫做

goroutine

，🎜🎜goroutine🎜🎜是并行处理任务的🎜🎜

🎜就像我用两只手同时操作两个手机打游戏一样🎜🎜

🎜goroutine🎜🎜由Go的🎜🎜runtime🎜🎜完成调度，🎜🎜goroutine 🎜像Java, Python, Python und Java

Wegen goroutinegoroutine是由runtime完成切换，并且runtime经过Google公司的数位大佬优化，已经很小母牛上山了，牛逼哄哄了。

<br>

使用goroutine

在Go中使用goroutine很简单，只需要在想调用的函数前加一个go就行了，这就代表启动了一个goroutine Ja von

🎜Laufzeit🎜🎜Vollständige Umschaltung , Und 🎜🎜Laufzeit🎜🎜Von Google Optimiert von den digitalen Meistern hat die kleine Kuh den Berg erklommen, und sie ist so großartig. ?? 1rem;Rand unten: 1rem;Schriftstärke: fett;Zeilenhöhe: 1,225;Cursor: Text;Padding-unten: 0,3em;Rahmen unten: 1px solid rgb(238, 238, 238);white-space: pre-wrap;font-family: „Open Sans“, „Clear Sans“, „Helvetica Neue“, Helvetica, Arial, sans-serif;text-align: start;“>🎜Use goroutine🎜

🎜Use in Go🎜🎜goroutine🎜🎜 ist sehr einfach, Sie müssen es nur dann aufrufen, wenn Sie möchten 🎜 Fügen Sie einfach go vor der Funktion hinzu🎜🎜, was bedeutet, dass ein 🎜🎜goroutine🎜🎜

Normale Aufruffunktionsmethode

Funktion

func Say() {
    time.Sleep(time.Second)
    fmt.Println("我在说话说了1s说完了...")
}

main<br>

func main() {
    //开始时间
    var start_time = time.Now()
    //启动10个say说话
    for i := 0; i < 10; i++ {
        Say()
}
    //结束时间
    var end_time = time.Now()
    //计算时间差
    fmt.Println(end_time.Sub(start_time))
}

Ausführung. Ergebnis<br>

Es wurde 10 Mal wiederholt und dauerte 10 Sekunden, was ein bisschen ist langsam! <br>

<br>

Goroutine-Methode zum Aufrufen von Funktionen

Die Funktion ist immer noch die obige Funktion

main

func main() {
    //开始时间
    var start_time = time.Now()
    //启动10个say说话
    for i := 0; i < 10; i++ {
        go Say()
}
    //结束时间
    var end_time = time.Now()
    //计算时间差
    fmt.Println(end_time.Sub(start_time))
}

Hinweis: Zeile 6, „Gehe hinein“ hinzufügen Das Schlüsselwort „front“ bedeutet, dass diese Funktion separat in einem Mikrothread ausgeführt wird. <br>

Ausführungsergebnisse

was??? 0er, was ist los? <br>

<br>

Warum kommt es zu dieser Nullensituation? Das liegt daran, dass wir in Go die Daemon-Thread-Methode verwenden.

Solange in Go die Hauptfunktion ausgeführt wird, sind andere Mikrothreads inaktiv.

Genau wie manche Monster sind sie aufeinander angewiesen und haben einen Mutterkörper. Wenn der Mutterkörper stirbt, stirbt auch das Baby darunter.

Wie kann man dieses Problem lösen???? Sie konnten ausgeführt werden, da die

Hauptfunktion

zu schnell lief,

<br>main die Ausführung beendete

und die Go-Laufzeit automatisch andere Mikrothreads schloss.

Dann überlegen Sie andererseits, wie schaffen wir es, am Ende den Hauptlauf zu machenMoment mal, wenn meine Kinder zurück sind, werde ich weiterlaufen.

所以，有一个新的问题，那就是等，祭出法宝sync.WaitGroup

先看一下怎么用

函数

func Say() {
    //函数结束时取消标记
    defer wg.Done()
    //每个函数在启动时加上一个标记
    wg.Add(1)
    //函数开始打上一个标记
    time.Sleep(time.Second*1)
    fmt.Println("我在说话说了1s说完了...")
}

main<br>

var wg  sync.WaitGroup
func main() {
    //开始时间
    var start_time = time.Now()
    //启动10个say说话
    for i := 0; i < 10; i++ {
        go Say()
}
    // 等待所有标记过的微线程执行完毕
    wg.Wait()
    //结束时间
    var end_time = time.Now()
    //计算时间差
    fmt.Println(end_time.Sub(start_time))
}

执行结果<br>

可以看到，10个线程同时启动，1s就完了，并且代码相对简单，就算开启10w个，还是1s多一点<br>

这也是为什么很多公司越来越青睐Go的原因。

runtime.GOMAXPROCS<br>

这个意思要使用多少个核，默认使用全部核心，性能跑满，但是也有意外的情况，

比如一个机器跑了很多其他任务，Go写的这个是不太重要的任务，但是是计算型的，这时候理论来说是不尽量挤兑别人的算力

所以要限制一下当前程序使用电脑的算力

代码

func main() {
    //本机的cpu个数
    var cpuNum = runtime.NumCPU()
    fmt.Println(cpuNum)
    //设置Go使用cpu个数
    runtime.GOMAXPROCS(4)
}

<br>

总结<br>

上述我们学习了Go的并发，学习了

• 如何创建一个协程(goroutine)。

• 为什么需要sync.WaitGroup。

• 设置当前程序使用CPU核数。

Das obige ist der detaillierte Inhalt vonEin Artikel, der Sie in die Grundlagen der Parallelität der Go-Sprache einführt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!