同期
Sync
安全に併用できる並行処理を作りたい。
安全でない並行処理から始めて、その動作がシングルスレッド環境で機能することを確認します。
次に、複数のゴルーチンがテストを介してそれを使用して修正することで、安全でないことを実行します。

最初にテストを書く

APIで、カウンターをインクリメントしてその値を取得するメソッドを提供する必要があります。
1
func TestCounter(t *testing.T) {
2
t.Run("incrementing the counter 3 times leaves it at 3", func(t *testing.T) {
3
counter := Counter{}
4
counter.Inc()
5
counter.Inc()
6
counter.Inc()
7
8
if counter.Value() != 3 {
9
t.Errorf("got %d, want %d", counter.Value(), 3)
10
}
11
})
12
}
Copied!

テストを実行してみます

1
./sync_test.go:9:14: undefined: Counter
Copied!

テストを実行するための最小限のコードを記述し、失敗したテスト出力を確認します

Counterを定義しましょう。
1
type Counter struct {
2
3
}
Copied!
再試行して、次のように失敗します。
1
./sync_test.go:14:10: counter.Inc undefined (type Counter has no field or method Inc)
2
./sync_test.go:18:13: counter.Value undefined (type Counter has no field or method Value)
Copied!
最終的にテストを実行するために、これらのメソッドを定義できます。
1
func (c *Counter) Inc() {
2
3
}
4
5
func (c *Counter) Value() int {
6
return 0
7
}
Copied!
実行して失敗するはずです。
1
=== RUN TestCounter
2
=== RUN TestCounter/incrementing_the_counter_3_times_leaves_it_at_3
3
--- FAIL: TestCounter (0.00s)
4
--- FAIL: TestCounter/incrementing_the_counter_3_times_leaves_it_at_3 (0.00s)
5
sync_test.go:27: got 0, want 3
Copied!

成功させるのに十分なコードを書く

これは、私たちのようなGoの専門家にとっては簡単なことです。データ型のカウンターの状態を保持し、Incを呼び出すたびにインクリメントする必要があります
1
type Counter struct {
2
value int
3
}
4
5
func (c *Counter) Inc() {
6
c.value++
7
}
8
9
func (c *Counter) Value() int {
10
return c.value
11
}
Copied!

リファクタリング♪

リファクタリングすることはそれほど多くありませんが、Counterを中心にさらに多くのテストを作成するので、テストが少し明確に読み取れるように、小さなアサーション関数assertCountを作成します。
1
t.Run("incrementing the counter 3 times leaves it at 3", func(t *testing.T) {
2
counter := Counter{}
3
counter.Inc()
4
counter.Inc()
5
counter.Inc()
6
7
assertCounter(t, counter, 3)
8
})
9
10
func assertCounter(t *testing.T, got Counter, want int) {
11
t.Helper()
12
if got.Value() != want {
13
t.Errorf("got %d, want %d", got.Value(), want)
14
}
15
}
Copied!

次のステップ

それは十分に簡単でしたが、現在は、並行環境で使用しても安全である必要があるという要件があります。これを実行するには、失敗するテストを作成する必要があります。

最初にテストを書く

1
t.Run("it runs safely concurrently", func(t *testing.T) {
2
wantedCount := 1000
3
counter := Counter{}
4
5
var wg sync.WaitGroup
6
wg.Add(wantedCount)
7
8
for i := 0; i < wantedCount; i++ {
9
go func(w *sync.WaitGroup) {
10
counter.Inc()
11
w.Done()
12
}(&wg)
13
}
14
wg.Wait()
15
16
assertCounter(t, counter, wantedCount)
17
})
Copied!
これは、wantedCountをループし、goroutineを起動して、counter.Inc()を呼び出します。
並行プロセスを同期する便利な方法であるsync.WaitGroupを使用しています。
WaitGroupは、ゴルーチンのコレクションが完了するのを待ちます。メインのゴルーチンはAddを呼び出して、待機するゴルーチンの数を設定します。次に、各ゴルーチンが実行され、完了したらDoneを呼び出します。同時に、すべてのゴルーチンが完了するまで、Waitを使用してブロックすることができます。
アサーションを作成する前にwg.Wait()が完了するのを待つことで、すべてのゴルーチンがCounterIncしようとしたことを確認できます。

テストを実行してみます

1
=== RUN TestCounter/it_runs_safely_in_a_concurrent_envionment
2
--- FAIL: TestCounter (0.00s)
3
--- FAIL: TestCounter/it_runs_safely_in_a_concurrent_envionment (0.00s)
4
sync_test.go:26: got 939, want 1000
5
FAIL
Copied!
テストは別の数値で おそらく 失敗しますが、それでも複数のゴルーチンが同時にカウンターの値を変更しようとしている場合は機能しないことを示しています。

成功させるのに十分なコードを書く

簡単な解決策は、CounterMutexにロックを追加することです。
Mutexは相互排他ロックです。ミューテックスのゼロ値は、ロックされていないミューテックスです。
1
type Counter struct {
2
mu sync.Mutex
3
value int
4
}
5
6
func (c *Counter) Inc() {
7
c.mu.Lock()
8
defer c.mu.Unlock()
9
c.value++
10
}
Copied!
これが意味することは、Incを呼び出すgoroutineが最初にある場合、Counterのロックを取得することです。他のすべてのゴルーチンは、アクセスを取得する前に、それがUnlockされるのを待つ必要があります。
ここでテストを再実行すると、変更を行う前に各ゴルーチンが順番を待たなければならないため、テストに合格するはずです。

sync.Mutexが構造体に埋め込まれている他の例を見てきました。

あなたはこのような例を見るかもしれません
1
type Counter struct {
2
sync.Mutex
3
value int
4
}
Copied!
それはコードをもう少しエレガントにすることができると主張することができます。
1
func (c *Counter) Inc() {
2
c.Lock()
3
defer c.Unlock()
4
c.value++
5
}
Copied!
これは見栄えが良いですが、プログラミングは非常に主観的な分野ですが、これは悪いことであり間違っています
場合によっては、型の埋め込みがその型のメソッドが public インターフェースの一部になることを忘れることがあります。そしてあなたはしばしばそれを望まないでしょう。 公開APIには細心の注意を払う必要があることを忘れないでください。何かを公開する瞬間は、他のコードがそれに結合できる瞬間です。私たちは常に不必要な結合を避けたいと思っています。
LockUnlockを公開することはせいぜい混乱を招きますが、最悪の場合、同じタイプの呼び出し元がこれらのメソッドの呼び出しを開始すると、ソフトウェアに非常に有害な可能性があります。
このAPIのユーザーがロックの状態を誤って変更する方法を示します
これは本当に悪い考えのようです

mutexesのコピー

テストはパスしましたが、コードはまだ少し危険です
コードでgo vetを実行すると、次のようなエラーが表示されます
1
sync/v2/sync_test.go:16: call of assertCounter copies lock value: v1.Counter contains sync.Mutex
2
sync/v2/sync_test.go:39: assertCounter passes lock by value: v1.Counter contains sync.Mutex
Copied!
sync.Mutexのドキュメントを見ると理由がわかります
ミューテックスは、最初の使用後にコピーしてはなりません。
Counter(by value)をassertCounterに渡すと、ミューテックスのコピーが作成されます。
これを解決するには、代わりにCounterへのポインターを渡す必要があるため、assertCounterのシグネチャを変更します
1
func assertCounter(t *testing.T, got *Counter, want int)
Copied!
*CounterではなくCounterを渡そうとしているため、テストはコンパイルされなくなりました。これを解決するには、自分で型を初期化しない方がよいことをAPIのリーダーに示すコンストラクタを作成することをお勧めします。
1
func NewCounter() *Counter {
2
return &Counter{}
3
}
Copied!
Counterを初期化するときに、この関数をテストで使用します。

まとめ

同期パッケージ(sync package)のいくつかをカバーしました
  • Mutexを使用すると、データにロックを追加できます
  • Waitgroupは、ゴルーチンがジョブを完了するのを待つ手段です

チャネルとゴルーチンにロックを使用するのはいつですか?

Goの初心者によくある間違いは、それが可能であったり、楽しいからといって、チャネルやゴルーチンを使いすぎてしまうことです。sync.Mutexが問題に最も適している場合は、恐れずに同期を使用してください。 Goは、問題を最もよく解決するツールを使用できるようにし、1つのスタイルのコードに強制するのではなく、実用的です。
言い換え
  • データの所有権を渡すときにチャネルを使用する
  • 状態の管理にミューテックスを使用する

go vet

ビルドスクリプトでgo vetを使用することを忘れないでください。貧弱なユーザーに影響が及ぶ前に、コード内のいくつかの微妙なバグを警告することができます。

便利なので埋め込みを使わないでください

  • 埋め込みがパブリックAPIに与える影響について考えてください。
  • これらのメソッドを 本当に 公開したいですか?
  • ミューテックスに関しては、これは非常に予測不能で奇妙な方法で潜在的に悲惨なものになる可能性があります。あるべきでないミューテックスをロック解除するいくつかの悪意のあるコードを想像してください。これは非常に奇妙なバグを引き起こし、追跡が困難になります。