Go言語のMutex TryLockを用いた効率的な並行処理実装方法を解説

package main
import (
	"fmt"
	"sync"
)
func main() {
	// サンプルリソースとMutexの初期化
	var mu sync.Mutex
	counter := 0
	// クリティカルセクション内でカウンタをインクリメント
	mu.Lock() // ロックを取得
	counter++
	fmt.Printf("Counter: %d\n", counter)
	mu.Unlock() // ロックを解除
}

Counter: 1

package main
import (
	"fmt"
)
// TryLock構造体はチャネルを利用してロック状態を管理する
type TryLock struct {
	ch chan struct{}
}
// NewTryLockはTryLock構造体の初期化を行う
func NewTryLock() *TryLock {
	// バッファサイズ1のチャネルを作成
	return &TryLock{ch: make(chan struct{}, 1)}
}
// Lockはブロッキングでロックを取得する
func (tl *TryLock) Lock() {
	tl.ch <- struct{}{}
}
// Unlockはロックを解除する
func (tl *TryLock) Unlock() {
	<-tl.ch
}
// TryLockはロック取得を試み、成功した場合はtrueを返す
func (tl *TryLock) TryLock() bool {
	select {
	case tl.ch <- struct{}{}:
		return true
	default:
		return false
	}
}
func main() {
	lock := NewTryLock()
	if lock.TryLock() {
		fmt.Println("Lock acquired using TryLock")
		lock.Unlock()
	} else {
		fmt.Println("Could not acquire lock using TryLock")
	}
}

Lock acquired using TryLock

package main
import (
	"fmt"
	"sync"
	"time"
)
// MutexWrapperはsync.Mutexをラップし、TryLock機能を提供する
type MutexWrapper struct {
	mu   sync.Mutex
	flag bool
}
// Lockは通常のロック取得を行う
func (mw *MutexWrapper) Lock() {
	mw.mu.Lock()
	mw.flag = true
}
// Unlockはロック解除を行う
func (mw *MutexWrapper) Unlock() {
	mw.flag = false
	mw.mu.Unlock()
}
// TryLockは、一定時間内にロック取得ができるかを試みる
func (mw *MutexWrapper) TryLock() bool {
	// 非同期でロックを取得する試行を開始
	resultChan := make(chan bool, 1)
	go func() {
		mw.mu.Lock()
		resultChan <- true
	}()
	// タイムアウトを設け、ブロッキングしないようにする
	select {
	case <-resultChan:
		if !mw.flag {
			mw.flag = true
			return true
		}
		mw.mu.Unlock()
		return false
	case <-time.After(10 * time.Millisecond):
		return false
	}
}
func main() {
	mw := &MutexWrapper{}
	if mw.TryLock() {
		fmt.Println("MutexWrapper: Lock acquired using TryLock")
		mw.Unlock()
	} else {
		fmt.Println("MutexWrapper: Could not acquire lock using TryLock")
	}
}

MutexWrapper: Lock acquired using TryLock

package main
import (
	"fmt"
	"sync"
	"time"
)
// Resourceは共有リソースの例
type Resource struct {
	mu   sync.Mutex
	data int
}
func main() {
	res := Resource{}
	// 別のゴルーチンがリソースを長時間保持するためのシミュレーション
	res.mu.Lock()
	go func() {
		time.Sleep(200 * time.Millisecond)
		res.mu.Unlock()
	}()
	// ロック取得を試みる処理(タイムアウトシミュレーション)
	tryLockSuccess := make(chan bool, 1)
	go func() {
		res.mu.Lock()
		tryLockSuccess <- true
		res.mu.Unlock()
	}()
	select {
	case success := <-tryLockSuccess:
		if success {
			fmt.Println("Lock acquired eventually")
		}
	case <-time.After(100 * time.Millisecond):
		fmt.Println("Lock acquisition failed, performing alternative processing")
	}
}

Lock acquisition failed, performing alternative processing

package main
import (
	"fmt"
	"time"
)
// TryLock構造体とメソッドは前述の実装を利用する
type TryLock struct {
	ch chan struct{}
}
func NewTryLock() *TryLock {
	return &TryLock{ch: make(chan struct{}, 1)}
}
func (tl *TryLock) Lock() {
	tl.ch <- struct{}{}
}
func (tl *TryLock) Unlock() {
	<-tl.ch
}
func (tl *TryLock) TryLock() bool {
	select {
	case tl.ch <- struct{}{}:
		return true
	default:
		return false
	}
}
// benchTryLockは反復回数分TryLockを実施し、所要時間を返す
func benchTryLock(iterations int) time.Duration {
	tl := NewTryLock()
	start := time.Now()
	for i := 0; i < iterations; i++ {
		if tl.TryLock() {
			tl.Unlock()
		}
	}
	return time.Since(start)
}
func main() {
	iterations := 1000000
	duration := benchTryLock(iterations)
	fmt.Printf("TryLock executed %d times in %v\n", iterations, duration)
}

TryLock executed 1000000 times in 15ms