コミュニティ 学ぶ ツールライブラリ レジャー
検索
日本語
ホームページ > バックエンド開発 > Golang > 本文

Go の高度な同時実行性をマスターする: コードのパワーとパフォーマンスを向上させる

Susan Sarandon
リリース： 2024-11-19 07:41:02
オリジナル
633 人が閲覧しました

Mastering Go

並行性は Go の設計の基礎であり、それが Go 言語が非常に人気を得た理由の 1 つです。ほとんどの開発者は基本的なゴルーチンとチャネルに精通していますが、探索されるのを待っている高度なパターンの世界が存在します。

見落とされがちな強力な同期プリミティブである sync.Cond から始めましょう。これは、条件に基づいて複数のゴルーチンを調整する必要がある場合に特に便利です。簡単な例を次に示します:

var count int
var mutex sync.Mutex
var cond = sync.NewCond(&mutex)

func main() {
    for i := 0; i < 10; i++ {
        go increment()
    }

    time.Sleep(time.Second)
    cond.Broadcast()
    time.Sleep(time.Second)
    fmt.Println("Final count:", count)
}

func increment() {
    mutex.Lock()
    defer mutex.Unlock()
    cond.Wait()
    count++
}
ログイン後にコピー
ログイン後にコピー

この例では、sync.Cond を使用して複数の goroutine を調整しています。これらはすべて、カウントをインクリメントする前に信号を待ちます。このパターンは、特定の条件に基づいて複数のゴルーチンを同期する必要がある場合に便利です。

アトミック操作は、Go の同時実行ツールキットのもう 1 つの強力なツールです。これにより、ロックフリーの同期が可能になり、特定のシナリオでパフォーマンスを大幅に向上させることができます。アトミック操作を使用して単純なカウンターを実装する方法は次のとおりです。

var counter int64

func main() {
    for i := 0; i < 1000; i++ {
        go func() {
            atomic.AddInt64(&counter, 1)
        }()
    }
    time.Sleep(time.Second)
    fmt.Println("Counter:", atomic.LoadInt64(&counter))
}
ログイン後にコピー
ログイン後にコピー

このコードは、このような基本的な操作にミューテックスを使用するよりもはるかに単純で、潜在的に効率的です。

ここで、より複雑なパターンについて話しましょう。ファンアウト/ファンイン パターンは、作業を並列化する強力な方法です。簡単な実装は次のとおりです。

func fanOut(input <-chan int, workers int) []<-chan int {
    channels := make([]<-chan int, workers)
    for i := 0; i < workers; i++ {
        channels[i] = work(input)
    }
    return channels
}

func fanIn(channels ...<-chan int) <-chan int {
    var wg sync.WaitGroup
    out := make(chan int)

    output := func(c <-chan int) {
        for n := range c {
            out <- n
        }
        wg.Done()
    }

    wg.Add(len(channels))
    for _, c := range channels {
        go output(c)
    }

    go func() {
        wg.Wait()
        close(out)
    }()

    return out
}

func work(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}
ログイン後にコピー
ログイン後にコピー

このパターンでは、複数のゴルーチンに作業を分散して結果を収集できます。これは、並列化できる CPU 依存タスクに非常に役立ちます。

ワーカー プールは、同時プログラミングにおけるもう 1 つの一般的なパターンです。これらを使用すると、同時に実行するゴルーチンの数を制限できます。これは、リソースの使用状況を管理する上で非常に重要です。簡単な実装は次のとおりです。

func workerPool(jobs <-chan int, results chan<- int, workers int) {
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- job * 2
            }
        }()
    }
    wg.Wait()
    close(results)
}
ログイン後にコピー
ログイン後にコピー

このワーカー プールはジョブを同時に処理しますが、同時操作の数はワーカーの数に制限されます。

パイプラインは Go のもう 1 つの強力なパターンです。これらを使用すると、複雑な操作を同時に処理できる段階に分割できます。簡単な例を次に示します:

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func sq(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func main() {
    for n := range sq(sq(gen(2, 3))) {
        fmt.Println(n)
    }
}
ログイン後にコピー
ログイン後にコピー

このパイプラインは数値を生成し、それらを二乗し、結果を再度二乗します。各ステージは独自の goroutine で実行され、同時処理が可能です。

実稼働システムでは正常なシャットダウンが重要です。正常なシャットダウンを実装するパターンは次のとおりです:

func main() {
    done := make(chan struct{})
    go worker(done)

    // Simulate work
    time.Sleep(time.Second)

    // Signal shutdown
    close(done)
    fmt.Println("Shutting down...")
    time.Sleep(time.Second) // Give worker time to clean up
}

func worker(done <-chan struct{}) {
    for {
        select {
        case <-done:
            fmt.Println("Worker: Cleaning up...")
            return
        default:
            fmt.Println("Worker: Working...")
            time.Sleep(100 * time.Millisecond)
        }
    }
}
ログイン後にコピー
ログイン後にコピー

このパターンにより、作業者は合図されたときに後片付けして正常に終了できます。

タイムアウト処理は、同時プログラミングのもう 1 つの重要な側面です。 Go の select ステートメントを使用すると、これが簡単になります。

func doWork() <-chan int {
    ch := make(chan int)
    go func() {
        time.Sleep(2 * time.Second)
        ch <- 42
    }()
    return ch
}

func main() {
    select {
    case result := <-doWork():
        fmt.Println("Result:", result)
    case <-time.After(1 * time.Second):
        fmt.Println("Timeout!")
    }
}
ログイン後にコピー

doWork が結果を生成するまでに 1 秒以上かかる場合、このコードはタイムアウトになります。

キャンセルの伝播は、一連の関数呼び出しを通じてキャンセル信号が受け渡されるパターンです。 Go のコンテキスト パッケージは次のように設計されています。

var count int
var mutex sync.Mutex
var cond = sync.NewCond(&mutex)

func main() {
    for i := 0; i < 10; i++ {
        go increment()
    }

    time.Sleep(time.Second)
    cond.Broadcast()
    time.Sleep(time.Second)
    fmt.Println("Final count:", count)
}

func increment() {
    mutex.Lock()
    defer mutex.Unlock()
    cond.Wait()
    count++
}
ログイン後にコピー
ログイン後にコピー

このパターンでは、長時間実行される操作を簡単にキャンセルできます。

それでは、実際の例をいくつか見てみましょう。ロード バランサの簡単な実装を次に示します。

var counter int64

func main() {
    for i := 0; i < 1000; i++ {
        go func() {
            atomic.AddInt64(&counter, 1)
        }()
    }
    time.Sleep(time.Second)
    fmt.Println("Counter:", atomic.LoadInt64(&counter))
}
ログイン後にコピー
ログイン後にコピー

このロード バランサーは、リクエストを最も負荷の低いサーバーに分散し、リアルタイムで負荷を更新します。

レート制限は、分散システムにおけるもう 1 つの一般的な要件です。単純なトークン バケットの実装は次のとおりです。

func fanOut(input <-chan int, workers int) []<-chan int {
    channels := make([]<-chan int, workers)
    for i := 0; i < workers; i++ {
        channels[i] = work(input)
    }
    return channels
}

func fanIn(channels ...<-chan int) <-chan int {
    var wg sync.WaitGroup
    out := make(chan int)

    output := func(c <-chan int) {
        for n := range c {
            out <- n
        }
        wg.Done()
    }

    wg.Add(len(channels))
    for _, c := range channels {
        go output(c)
    }

    go func() {
        wg.Wait()
        close(out)
    }()

    return out
}

func work(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}
ログイン後にコピー
ログイン後にコピー

このレート リミッターは、1 秒あたり一定数の操作を許可し、トラフィックのバーストを平滑化します。

分散タスクキューは、Go の同時実行機能の一般的な使用例です。簡単な実装は次のとおりです。

func workerPool(jobs <-chan int, results chan<- int, workers int) {
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- job * 2
            }
        }()
    }
    wg.Wait()
    close(results)
}
ログイン後にコピー
ログイン後にコピー

この分散タスク キューにより、複数のワーカーがタスクを同時に処理できます。

Go のランタイムは、ゴルーチンを管理するための強力なツールを提供します。 GOMAXPROCS 関数を使用すると、Go コードを同時に実行できる OS スレッドの数を制御できます:

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func sq(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func main() {
    for n := range sq(sq(gen(2, 3))) {
        fmt.Println(n)
    }
}
ログイン後にコピー
ログイン後にコピー

これにより、OS スレッドの数が CPU の数に設定され、CPU バウンドのタスクのパフォーマンスが向上します。

同時実行コードの最適化には、多くの場合、並列処理とゴルーチンの作成と管理のオーバーヘッドとの間のバランスをとる必要があります。 pprof のようなプロファイリング ツールは、ボトルネックの特定に役立ちます:

func main() {
    done := make(chan struct{})
    go worker(done)

    // Simulate work
    time.Sleep(time.Second)

    // Signal shutdown
    close(done)
    fmt.Println("Shutting down...")
    time.Sleep(time.Second) // Give worker time to clean up
}

func worker(done <-chan struct{}) {
    for {
        select {
        case <-done:
            fmt.Println("Worker: Cleaning up...")
            return
        default:
            fmt.Println("Worker: Working...")
            time.Sleep(100 * time.Millisecond)
        }
    }
}
ログイン後にコピー
ログイン後にコピー

このコードにより pprof が有効になり、同時実行コードのプロファイリングを行い、パフォーマンスの問題を特定できるようになります。

結論として、Go の同時実行機能は、効率的でスケーラブルなシステムを構築するための強力なツールキットを提供します。これらの高度なパターンとテクニックを習得することで、最新のマルチコア プロセッサを最大限に活用し、堅牢で高性能なアプリケーションを構築できます。同時実行性は単に速度に関するものではなく、複雑な現実世界のシナリオを処理できるクリーンで管理しやすいコードを設計することが重要であることに注意してください。さあ、これらの同時多発的な課題を克服していきましょう!

私たちの作品

私たちの作品をぜひチェックしてください:

インベスターセントラル | スマートな暮らし | エポックとエコー | 不可解な謎 | ヒンドゥーヴァ | エリート開発者 | JS スクール

私たちは中程度です

Tech Koala Insights | エポックズ＆エコーズワールド | インベスター・セントラル・メディア | 不可解なミステリー 中 | 科学とエポックミディアム | 現代ヒンドゥーヴァ

以上がGo の高度な同時実行性をマスターする: コードのパワーとパフォーマンスを向上させるの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。

ソース：dev.to
前の記事：Go HTTP ハンドラーでコンテキスト値を安全に操作するにはどうすればよいですか? 次の記事：Go で JSON 配列を解析する方法: 成功の鍵は何ですか?
このウェブサイトの声明
この記事の内容はネチズンが自主的に寄稿したものであり、著作権は原著者に帰属します。このサイトは、それに相当する法的責任を負いません。盗作または侵害の疑いのあるコンテンツを見つけた場合は、admin@php.cn までご連絡ください。
著者別の最新記事
最新の問題
function_exists() はカスタム関数を決定できません Function test () {return true;} if (function_exists ('test')) {echo "テストは関数です";
から 2024-04-29 11:01:01
0
2
1961
Google Chromeのモバイル版を表示する方法 こんにちは、先生、Google Chrome をモバイル版に変更するにはどうすればよいですか?
から 2024-04-23 00:22:19
0
10
2122
子ウィンドウは親ウィンドウを操作しますが、出力は応答しません。 最初の 2 つの文は実行可能ですが、最後の文は実装できません。
から 2024-04-19 15:37:47
0
1
1789
親ウィンドウには出力がありません document.onclick = function(){ window.opener.document.write('私は子ウィンドウの出力です');
から 2024-04-18 23:52:34
0
1
1689
CSS マインド マッピングに関するコースウェアはどこにありますか? コースウェア
から 2024-04-16 10:10:18
0
0
1697
関連トピック
詳細>
人気のおすすめ
人気のチュートリアル
詳細>
関連するチュートリアル
人気のおすすめ
最新のコース
最新のダウンロード
詳細>
ウェブエフェクト
公式サイト
サイト素材
フロントエンドテンプレート