Go 言語の同時実行性の基本を紹介する記事

はじめに

Go 言語、特に 同時実行 で生まれた言語。 マイクロスレッド # を開始するたびに、マイクロスレッドの作成コストは約 # になります。 ##2KB はじめに

メモリー スティックのサイズを 4G## と仮定します。 #、マイクロスレッド 2kb、1G=1024M=1048576kb， 1048576/2=524288、50万以上

しかし、どれくらいか知っていますか？ Java や Python などの言語でのスレッドのコストは????、

2MB は 2 倍の価格から始まります

だから、興奮して好きなように使ってください Go で Web プログラムを書くことは、基本的に

Nginx と同じです

<br>

##ゴルーチン

Go のマイクロスレッドは

とも呼ばれますゴルーチン、ゴルーチンは、並列処理タスクの##です#私が両手を使って 2 台の携帯電話を同時に操作してゲームをプレイするのと同じように、

これを片手でプレイし、あれを片手でプレイするのではなく、これは切り替えゲームプレイ

##groutin

Go の ランタイム ## によってスケジュールが完了します#,goutine# の本質は、コード (ユーザー モード) レベルで切り替えることであり、コストは非常に小さいです。 Java と同様、Python などの言語のスレッドはオペレーティング システム (カーネル状態) レベルで完成する切り花であるため、コストが非常に高くなります

ゴルーチン は runtime によって切り替えられるため、そしてランタイムGoogle のデジタル ボスによる最適化後は、すでに山を登る非常に小さな牛のようで、素晴らしいです。

<br>

#Goroutine の使用

#Go での使用

#goroutine は非常に簡単です。呼び出したい 関数の前に go を追加するだけです。これは、 を開始することを意味します。 ゴルーチン

通常の関数呼び出しメソッド

Function

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

#実行結果<br>

10回ループして10秒かかりました。遅い！

<br>

<br>#関数メソッドを呼び出すゴルーチン

関数はまだ残っています上記と同じ 関数

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

注:

6 行目、先頭に go キーワードが追加されています。go キーワードは、この関数をマイクロスレッドで個別に実行することを意味します。 結果 <br>

#

何??? 0 さん、何が起こっているのですか? <br>

<br>

#なぜこの 0 の状況が発生するのですか

#これそれは、Go ではデーモン スレッド方式を使用するためですが、これはどういう意味ですか?

Go では、main 関数が実行されている限り、他のマイクロスレッドはアイドル状態になります。

他のモンスターと同じように、彼らはお互いに依存しており、母親がいます。母親が死ねば、下の赤ちゃんも死ぬことになります。

#それでは、この問題を解決する方法???

<br>

sync 。 WaitGroup

上で、いくつかのマイクロスレッドが開始されたが、実行する前にマイクロスレッドがハングアップしたことがわかりました。 main 関数

実行が速すぎたため、main の実行が終了しました、Go の実行中に他のマイクロスレッドが自動的に閉じられました。 では逆に考えてみましょう。

main を最後にするにはどうすればよいでしょうか。

ちょっと待ってください。 、子供たちがすべて戻ってくるまで待って、私は走り続けます。

所以，有一个新的问题，那就是等，祭出法宝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核数。

以上がGo 言語の同時実行性の基本を紹介する記事の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。