Go言語におけるMutexとChannelの違いと使い分けについて解説

package main
import (
	"fmt"
	"sync"
)
// sharedDataは複数のゴルーチンからアクセスされる変数です
var sharedData int
func main() {
	var mu sync.Mutex    // Mutexのインスタンスを用意
	var wg sync.WaitGroup
	// 5つのゴルーチンを起動してsharedDataにアクセスします
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			mu.Lock()               // クリティカルセクションに入る前にロック
			sharedData++            // 共有変数を更新
			fmt.Printf("ゴルーチン%d: sharedData=%d\n", id, sharedData)
			mu.Unlock()             // アクセスが終わったらアンロック
		}(i)
	}
	wg.Wait()
}

ゴルーチン0: sharedData=1
ゴルーチン1: sharedData=2
ゴルーチン2: sharedData=3
ゴルーチン3: sharedData=4
ゴルーチン4: sharedData=5

package main
import (
	"fmt"
)
func main() {
	// int型の値を送受信するChannelを作成(バッファなし)
	dataChannel := make(chan int)
	// ゴルーチンを起動してChannelにデータを送信する
	go func() {
		// Channelに値を送信
		dataChannel <- 42
		// コメント：42というデータを送信します
	}()
	// Channelからデータを受け取る
	value := <-dataChannel
	fmt.Printf("受信した値: %d\n", value)
}

受信した値: 42

package main
import (
	"fmt"
	"sync"
)
var count int
func increment(mu *sync.Mutex, wg *sync.WaitGroup, id int) {
	defer wg.Done()
	mu.Lock()            // 共有変数にアクセスする前にロック
	count++              // 変数countの値を更新
	fmt.Printf("Mutex ゴルーチン%d: count=%d\n", id, count)
	mu.Unlock()          // アクセス後にアンロック
}
func main() {
	var wg sync.WaitGroup
	var mu sync.Mutex
	// Mutexを利用した例
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go increment(&mu, &wg, i)
	}
	// Channelを利用した例
	dataChannel := make(chan string, 3)
	// Channelへ送信するゴルーチン
	for i := 0; i < 3; i++ {
		go func(id int) {
			data := fmt.Sprintf("Channel ゴルーチン%dのメッセージ", id)
			dataChannel <- data
		}(i)
	}
	// 送信されたデータを受信
	wg.Add(1)
	go func() {
		defer wg.Done()
		for i := 0; i < 3; i++ {
			msg := <-dataChannel
			fmt.Println(msg)
		}
	}()
	wg.Wait()
}

Mutex ゴルーチン0: count=1
Mutex ゴルーチン1: count=2
Mutex ゴルーチン2: count=3
Channel ゴルーチン0のメッセージ
Channel ゴルーチン1のメッセージ
Channel ゴルーチン2のメッセージ

package main
import (
	"fmt"
	"sync"
	"time"
)
// sharedResourceは複数のゴルーチンから更新される共有データです
var sharedResource int
func worker(mu *sync.Mutex, id int, resultChan chan<- string, wg *sync.WaitGroup) {
	defer wg.Done()
	// 何かしらの処理をシミュレートするために、スリープを実行
	time.Sleep(time.Millisecond * 100)
	// 共有リソースを安全に更新
	mu.Lock()
	sharedResource += id
	updatedValue := sharedResource
	mu.Unlock()
	// 処理結果のメッセージをChannelに送信
	resultMsg := fmt.Sprintf("Worker%d 完了: sharedResource=%d", id, updatedValue)
	resultChan <- resultMsg
}
func main() {
	var wg sync.WaitGroup
	var mu sync.Mutex
	// 結果を受け取るChannel(バッファ付き)
	resultChan := make(chan string, 3)
	// 複数のworkerを起動
	for i := 1; i <= 3; i++ {
		wg.Add(1)
		go worker(&mu, i, resultChan, &wg)
	}
	// 全てのworkerが終了するのを待機
	wg.Wait()
	close(resultChan)
	// 結果を出力
	for msg := range resultChan {
		fmt.Println(msg)
	}
}

Worker1 完了: sharedResource=1
Worker2 完了: sharedResource=3
Worker3 完了: sharedResource=6