Golang の同時実行は安全ではありませんか?

Golang は比較的若いプログラミング言語ですが、近年の急速な発展によりますます注目と愛を集めています。 Golang には組み込みの同時実行メカニズムがあるため、多くの開発者に好まれていますが、同時実行メカニズムを使用するといくつかの隠れた危険が生じます。特に同時実行が安全でない場合、プログラム内で一連の問題が発生する可能性があります。この記事では、Golang での安全でない同時実行の理由と解決策について説明します。

1. 同時実行が安全でない理由

1. 競合状態

競合状態とは、複数のスレッドが共有リソースにアクセスし、異なる操作により異なる結果が生じる場合を指します。 、競合状態と呼ばれる状況。 Golang では、コルーチンの非同期実行により、競合状態がより明白になります。

2. データ競合

データ競合とは、複数のコルーチンが同じメモリ領域に同時にアクセスし、少なくとも 1 つのコルーチンが書き込み操作を実行していることを意味します。 Golang の同時実行メカニズムにより、異なるコルーチンの実行時間は異なるため、複数のコルーチンが同じメモリ領域を同時に変更する可能性があります。

3. デッドロック

デッドロックとは、2 つ以上のコルーチンが互いのリソースの解放を待機しており、実行を続行できない状況を指します。この状況はロックを使用するときに発生する可能性があり、ロックが不適切に使用されるとデッドロックが発生します。

2. Golang における安全でない同時実行の例

以下は、Golang における安全でない同時実行の問題を説明する簡単な例です:

package main 
import (
   "fmt"
   "sync"
)
var num = 0 
func add(wg *sync.WaitGroup) {
   num++ 
   wg.Done()
}
func main() {
   var wg sync.WaitGroup
   for i := 0; i < 1000; i++ {
      wg.Add(1)
      go add(&wg)
   }
   wg.Wait()
   fmt.Println("num=", num)
}

この例では、A を定義します。グローバル変数 num を指定し、コルーチンを使用して add メソッドを呼び出し、num を 1000 回増分します。コルーチンの非同期実行のため、このプログラムの実行順序は不確実です。このコードが複数のコルーチンを同時に実行すると、データの競合が発生し、num の結果が予期した 1000 にならない可能性があります。

3. Golang で安全でない同時実行を回避する方法

1. ロックを使用する

ロックは、安全でない同時実行の問題を解決するためによく使用される方法の 1 つです。 sync.Mutex、sync.RWMutex などのロック実装。ロックを使用すると、同時に 1 つのコルーチンだけが特定のリソースにアクセスできるようになり、データ競合の発生を回避できます。

上記の例を変更し、sync.Mutex を使用してデータ競合を回避します。

package main 
import (
   "fmt"
   "sync"
)
var num = 0 
func add(wg *sync.WaitGroup, lock *sync.Mutex) {
   lock.Lock() 
   num++ 
   lock.Unlock()
   wg.Done()
}
func main() {
   var wg sync.WaitGroup
   var lock sync.Mutex 
   for i := 0; i < 1000; i++ {
      wg.Add(1)
      go add(&wg, &lock)
   }
   wg.Wait()
   fmt.Println("num=", num)
}

この例では、sync.Mutex を使用して、num への変更がアトミックであることを確認します。これにより、データ競合の発生が回避されます。

2. アトミック操作を使用する

Golang は、特定のリソースの操作がアトミックであることを保証するために、一連のアトミック操作を提供します。 sync/atomic パッケージ内の AddInt32、AddInt64、SwapInt32、SwapInt64 などのアトミック操作を使用して競合状態を回避します。

上記の例を変更し、アトミック操作を使用してデータ競合を回避します:

package main 
import (
   "fmt"
   "sync/atomic"
   "sync"
)
var num int32 
func add(wg *sync.WaitGroup) {
   atomic.AddInt32(&num,1) 
   wg.Done()
}
func main() {
   var wg sync.WaitGroup
   for i := 0; i < 1000; i++ {
      wg.Add(1)
      go add(&wg)
   }
   wg.Wait()
   fmt.Println("num=", num)
}

この例では、sync/atomic パッケージの AddInt32 関数を使用して、num への変更がアトミックであることを確認します。 . 競合状態の発生を回避します。

3. チャネルを使用する

チャネルは、Golang 同時プログラミングで非常に一般的に使用される同期メカニズムです。チャネルを使用すると、コルーチン間の通信が確実に同期されるため、競合状態やデータ競合の問題が回避されます。

上記の例を変更し、チャネルを使用してデータ競合を回避します:

package main 
import (
   "fmt"
   "sync"
)
func add(wg *sync.WaitGroup, ch chan int) {
   ch <- 1 
   wg.Done()
}
func main() {
   var wg sync.WaitGroup
   ch := make(chan int, 1000)
   for i := 0; i < 1000; i++ {
      wg.Add(1)
      go add(&wg, ch)
   }
   wg.Wait()
   close(ch)
   num := 0 
   for n := range ch {
      num += n
   }
   fmt.Println("num=", num)
}

この例では、チャネルを使用して num への変更が確実に同期されるようにすることで、データ競合の発生を回避します。

4. 概要

Golang の同時実行メカニズムは非常に魅力的な機能の 1 つですが、同時実行メカニズムを使用すると、特定のセキュリティ上の問題も発生します。この記事では、Golang の安全でない同時実行の理由と解決策について説明し、主に同時実行におけるデータ競合、競合状態、デッドロックの回避の側面から解決策を提供します。実際のプログラミングプロセスでは、特定のニーズに応じて適切なメカニズムを選択し、プログラムの品質と安全性を確保できます。

以上がGolang の同時実行は安全ではありませんか?の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。