[Go] data race와 mutex, atomic

Go는 고루틴을 기반으로 성능적으로 빼어난 비동기 시스템을 제공하기는 하지만, 동기화에 대한 안전성에 엄격하지는 않다. Rust처럼 빡세게 동시성을 검사하지는 않기 때문에 별 생각없이 짜다가는 동시성 버그가 나기 쉽다.

이런 것에 대한 대표적인 사례 중 하나가 data race일것 같다.

아래 코드는 data race가 발생하는 간단한 코드다.
고루틴 10개를 돌려서 단일 공유변수를 증가시키는 단순한 로직을 갖고 있다.

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	var shared = 0

	// 고루틴 10개 띄우기
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			// 각 고루틴은 공유변수를 10000번씩 증가시킴
			for j := 0; j < 10000; j++ {
				shared++
			}
		}()
	}

	wg.Wait()
	fmt.Println(shared) // 10 * 10000 = 100000가 나와야 하는데...?
}

우리의 기대대로라면 당연히 10만이 찍혀야 하건만

10만이 나오지도 않고, 일정한 값이 나오지도 않는다.
이걸 데이터 레이스라고 부르는데, 여러개의 스레드가 동시에 하나의 변수에 접근하니까, 각자의 읽기와 쓰기가 서로 충돌하면서 서로서로 덮어씌워버리는 것이다.

이걸 해결하려면 동기화 개념들을 적용해야 한다.
사실 이에 대한 가장 간편한 해결책은 채널이다.
https://blog.naver.com/sssang97/223176685609
하지만 채널은 수신자와 송신자가 명확하게 구분되는 케이스에만 적합하고, 각 스레드들이 읽기/쓰기를 능동적으로 해야 하는 경우에는 사용하기가 곤란하다. 이럴 때는 직접 락을 걸거나 해야 한다.

Mutex

Mutex는 언어를 초월해서 가장 일반적으로 사용되는 동기화 기술이다.
https://blog.naver.com/sssang97/223131650074

그냥 무식하게 락걸고 다른놈이 접근하지 못하게 하는게 다다.
간단하고 강력하지만, 너무 남발하면 성능 저하가 심할 수 있고, 데드락의 문제도 항상 고려해야 한다.

아래 코드에서는 mutex를 적용해서 data race를 해결한다.

우선 뮤텍스틀 공유용으로 선언한 다음에

쓰기를 할때마다 락을 걸고 풀도록 했다.

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	var shared = 0
	var mutex = sync.Mutex{} // 공유변수를 보호할 뮤텍스 생성

	// 고루틴 10개 띄우기
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			// 각 고루틴은 공유변수를 10000번씩 증가시킴
			for j := 0; j < 10000; j++ {
				mutex.Lock() // 공유변수 보호 시작
				shared++
				mutex.Unlock() // 공유변수 보호 종료
			}
		}()
	}

	wg.Wait()
	fmt.Println(shared) // 10 * 10000 = 100000가 나와야 하는데...?
}

그럼 약간 느려지긴 하지만 의도대로 동작은 한다.

atomic

mutex lock으로 인한 성능 병목이 심각하게 우려될 경우에는, atomic 기능들을 응용하는게 좋을 수 있다.
이건 무식하게 락을 거는게 아니고, CPU 인스트럭션 수준에서 제공하는 특정 기술을 활용해서 충돌을 방지하는 기술이다.

내가 알기로 내장 atomic 기능은 Compare And Swap을 기반으로 atomic을 제공한다. 확실하지는 않다.
https://blog.naver.com/sssang97/222721792446

아래에서는 atomic을 활용해서 data race를 제거해봤다.

그냥 덧셈이란 행위 자체를 atomic operation으로 처리하게 하는 것이다.

package main

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

func main() {
	var wg sync.WaitGroup
	var shared int32 = 0

	// 고루틴 10개 띄우기
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			// 각 고루틴은 공유변수를 10000번씩 증가시킴
			for j := 0; j < 10000; j++ {
				atomic.AddInt32(&shared, 1)
			}
		}()
	}

	wg.Wait()
	fmt.Println(shared) // 10 * 10000 = 100000가 나와야 하는데...?
}

그럼 기대하던대로 빠르게도 나오고, 성능도 충분히 나올 것이다.

여기서는 그냥 쓰기만 무식하게 해서 atomic이 좋아보일 수도 있는데, 타입이 복잡하거나 읽기와 쓰기, 검증 등이 필요한 경우에는 atomic으로는 한계가 있을 수도 있다.

참조
https://pkg.go.dev/sync/atomic
https://ikcoo.tistory.com/m/214