Go でロックを使用するにはどうすればよいですか?

並行プログラミングでは、ロックは共有リソースを保護するために使用されるメカニズムです。 Go 言語では、ロックは同時実行性を実現するための重要なツールの 1 つです。これにより、複数のコルーチンが共有リソースに同時にアクセスした場合、1 つのコルーチンだけがこれらのリソースを読み取りまたは変更できるようになります。この記事では、読者が並行プログラミングをよりよく理解できるように、Go 言語でのロックの使用法を紹介します。

1. 相互排他ロック

相互排他ロックは、Go 言語で最も一般的に使用されるロック メカニズムです。これにより、クリティカル セクションに同時にアクセスできるコルーチンは 1 つだけになります。平たく言えば、ミューテックス ロックは、共有リソースをロック クリティカル セクションでラップすることにより、同時に 1 つのコルーチンのみがアクセスできるようにします。

Go 言語でのミューテックス ロックの使用は非常に簡単です。同期パッケージの Mutex タイプを使用して、mutex ロックを作成できます:

import "sync"

var mutex = &sync.Mutex{}

その後、共有リソースを保護する必要がある場所で、次のコードを使用してロックを取得できます。 ##

mutex.Lock()
defer mutex.Unlock()

価値があります ミューテックス ロックは再入をサポートしていないことに注意してください。コルーチンがすでにロックを取得している場合、再度ロックを取得しようとするとデッドロックが発生します。したがって、通常は defer ステートメントを使用して、コルーチンの終了時にロックを自動的に解放します。

次に、ミューテックス ロックの使用例を示します。

import (
    "fmt"
    "sync"
)

var count = 0
var mutex = &sync.Mutex{}

func increment(wg *sync.WaitGroup) {
    mutex.Lock()
    defer mutex.Unlock()
    count++
    wg.Done()
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go increment(&wg)
    }
    wg.Wait()
    fmt.Println("Count:", count)
}

この例では、ミューテックス ロックを使用してカウンターを保護します。 1000 個のコルーチンがインクリメント関数を同時に実行し、毎回カウンターに 1 を加算します。ミューテックス ロックを使用しているため、プログラムは最終的なカウンター値を正しく出力できます。

読み取り/書き込みロック

マルチコルーチン環境では、読み取り/書き込みロック (読み取り/書き込みロック) がミューテックス ロックよりも優れている場合があります。対照的に、複数のコルーチンが共有リソースから同時に読み取る場合は効率を維持できますが、書き込み操作がある場合は依然として相互排他的アクセスが必要です。

読み取り/書き込みロックは、読み取りロックと書き込みロックの 2 種類のロックで構成されます。読み取りロックを使用すると、複数のコルーチンが共有リソースに同時にアクセスできますが、書き込みロックを使用すると、同時に 1 つのコルーチンのみがアクセスできるようになります。

Go 言語では、同期パッケージの RWMutex タイプを使用して読み取り/書き込みロックを作成できます。

import "sync"

var rwlock = &sync.RWMutex{}

読み取りロックと書き込みロックの取得方法は異なります。一般的な使用法は次のとおりです。

読み取りロックの取得: rwlock.RLock()
読み取りロックの解放: rwlock.RUnlock()
書き込みロックの取得: rwlock.Lock()
書き込みロックを解放します: rwlock.Unlock()

次に、読み取り/書き込みロックの使用例を示します:

import (
    "fmt"
    "sync"
)

var count = 0
var rwlock = &sync.RWMutex{}

func increment(wg *sync.WaitGroup) {
    rwlock.Lock()
    defer rwlock.Unlock()
    count++
    wg.Done()
}

func read(wg *sync.WaitGroup) {
    rwlock.RLock()
    defer rwlock.RUnlock()
    fmt.Println("Count:", count)
    wg.Done()
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go increment(&wg)
    }
    wg.Wait()

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go read(&wg)
    }
    wg.Wait()
}

この例では、カウンタにデータを書き込むために 10 個のコルーチンを開き、カウンタ データを読み取るために 5 個のコルーチンを同時に開きました。読み取り/書き込みロックを使用すると、プログラムは書き込み操作のアトミック性を確保しながら、効率的な方法で共有リソースから読み取ることができます。

アトミック操作

Go 言語では、アトミック操作を使用して、同期プリミティブの操作がアトミックであることを確認することもできます。アトミック操作はロックを必要としないため、状況によってはロックよりも効率的です。

Go 言語には複数のアトミック操作関数が組み込まれています。公式ドキュメントを参照してください。ここでは、一般的に使用される 2 つのアトミック操作関数、atomic.Add と atomic.Load を示します。

atomic.Add: 整数に対してアトミックな加算操作を実行します。
atomic.Load: 整数の値をアトミックに読み取ります。

次は例です:

import (
    "fmt"
    "sync/atomic"
    "time"
)

var count int32 = 0

func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    atomic.AddInt32(&count, 1)
}

func printCount() {
    fmt.Println("Count: ", atomic.LoadInt32(&count))
}

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go increment(&wg)
    }
    wg.Wait()
    printCount()

    time.Sleep(time.Second)

    for i := 0; i < 3; i++ {
        wg.Add(1)
        go increment(&wg)
    }
    wg.Wait()
    printCount()
}

この例では、atomic.Add 関数を使用してカウンターに対してアトミックな加算操作を実行し、atomic.Load 関数を使用してカウンタに対してアトミックな加算操作を実行します。カウンタ値をアトミックに読み取ります。アトミック操作を使用することで、ロックのオーバーヘッドを回避し、より効率的な同時プログラミングを実現できます。

概要

Go 言語は、ミューテックス ロック、読み取り/書き込みロック、アトミック操作などのさまざまな同期メカニズムを提供します。同時プログラミングで適切な同期メカニズムを使用することは、プログラムを正しく効率的に実行するための鍵となります。デッドロックを回避するには、現在の共有リソースにどのロック メカニズムが最適であるかを慎重に考える必要があります。 Go 言語では、ロックの使用方法は非常に簡単です。プログラムのパフォーマンスの低下を避けるために、ロック保持時間を可能な限り短縮する必要があることに注意してください。

以上がGo でロックを使用するにはどうすればよいですか?の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。