[Go] 고루틴(Goroutine)

들어가며

고루틴은 Go의 비동기 메커니즘입니다. Go의 최대 매력포인트라고 봐도 과언이 아니죠. 고루틴을 사용하면 이벤트 처리, 병렬 프로그래밍이 간단해집니다. Go는 비동기 측면에서 다른 언어와 다르게 CSP(Communicating Sequential Processes)라는 학술적 모델을 사용하고 있습니다. 그래서 고루틴과 채널방식이 탄생하게 됐습니다. 또한 고루틴으로 실행하는 스레드 단위가 경량(2KB)이기 때문에 10만개의 task도 고루틴으로 처리할 수 있습니다(일반적인 OS 스레드는 1MB 용량). 

 

 

고루틴 스케줄러

출처: https://ykarma1996.tistory.com/188

Go의 스케줄러는 유저 레벨 스레드 스케줄러(user-space scheduler) 입니다. 즉, OS가 아닌 Go 런타임이 직접 goroutine을 OS thread 위에서 스케줄링합니다. 핵심 목표는 수십만 개의 동시 실행 단위를 효율적으로 관리하는 것입니다. Go 런타임은 3가지 주요 엔티티(GMP)로 구성됩니다.

요소	설명	비유
G (Goroutine)	실행 단위 (함수 + 스택 + 상태)	작업(Task)
M (Machine)	실제 OS Thread	근로자(Thread)
P (Processor)	실행 가능한 context (run queue 포함)	작업대(Execution Slot)

G는 독립적인 실행 경로와 스택을 가지며 M에 의해 실행됩니다. M은 우리가 아는 OS thread입니다. P는 로컬 스케줄러 역할을 하는 구조체로, 실행할 고루틴 목록을 관리하고 M에게 고루틴을 제공합니다. 시스템의 각 CPU코어에는 하나의 P가 할당됩니다. 

 

스케줄링 프로세스

+-----------------------------+
|        Go Runtime           |
+-----------------------------+
|  P1 → runq: G1, G2, G3      |
|  P2 → runq: G4, G5          |
|  M1 <-> P1                  |
|  M2 <-> P2                  |
|  Global Run Queue           |
+-----------------------------+

 

기본 흐름:

1. OS Thread(M)는 P를 점유해야만 goroutine(G)을 실행할 수 있습니다.
2. 각 P는 자체 run queue를 가지고 있어 G를 로컬에서 우선 실행합니다.
3. 로컬 queue가 비면, 다른 P의 queue에서 work stealing을 수행합니다.
4. 실행 중 blocking syscall(I/O 등)이 발생하면:
   • 해당 M은 block됨.
   • Go runtime은 새로운 M을 생성해 남은 G들을 계속 실행합니다.
     → 즉, Blocking I/O가 전체 실행을 막지 않습니다.

 

용어 설명

• Run Queue:  각 P는 실행할 고루틴 목록을 가진 로컬 run queue를 가지고 있으며 M이 queue에서 고루틴을 가져와 실행합니다.
• Work Stealing: P의 로컬 run queue가 비어 있으면, 다른 P의 run queue에서 고루틴을 ‘훔쳐’올 수 있습니다. 이를 통해 부하를 균등하게 분산시키고 CPU 사용률을 최적화합니다.
• Syscall and Blocking: 고루틴이 시스템 호출을 하거나 블로킹 연산을 수행하면, 해당 고루틴은 블락 상태가 되고 다른 고루틴이 실행됩니다.
• Global Run Queue: 시스템 전체에서 사용할 수 있는 글로벌 run queue도 존재합니다. 새로 생성된 고루틴은 이 글로벌 run queue에 추가되며, P는 필요에 따라 이곳에서 고루틴을 가져올 수 있습니다.
• Spinning :P가 고루틴을 실행할 준비가 되었지만 로컬 run queue가 비어있을 때, P는 다른 P의 run queue에서 작업을 훔치려고 시도할 수 있습니다.

 

병렬성(Parallelism)과 동시성(Concurrency)

• 동시성(Concurrency): 여러 goroutine이 진행 중인 상태를 유지.
• 병렬성(Parallelism): 실제로 여러 CPU에서 동시에 실행.

Go의 스케줄러는 Concurrency를 보장하지만,
병렬 실행 수는 GOMAXPROCS 환경 변수에 의해 제한됩니다.

runtime.GOMAXPROCS(4)

→ 최대 4개의 P가 동시에 goroutine을 실행할 수 있습니다(즉, 4개 코어 사용).

 

Go routine 코드

package main
import "fmt"

func hello() {
	fmt.Println("Hello, world!")
}

func main() {
	go hello() // 함수를 고루틴으로 실행
	fmt.Scanln() // main 함수가 종료되지 않도록 대기
}

함수를 호출할 때 앞에 go 키워드를 붙이면 해당 함수는 고루틴으로 실행됩니다. 여기서는 hello 함수를 고루틴으로 실행합니다. 고루틴으로 hello 함수를 실행하면 main 함수와 동시에 실행되기 때문에 hello 함수 안의 fmt.Println이 호출되기 전에 main 함수가 종료되어버립니다. 따라서 fmt.Scanln을 사용하여 main 함수가 종료되지 않도록 대기합니다(엔터를 입력하면 대기를 끝냅니다).

다음은 반복문을 사용하여 고루틴을 100개 생성합니다.

package main

import (
"fmt"
"math/rand"
"time"
)

func hello(n int) {

	r := rand.Intn(100) // 랜덤한 숫자 생성
	time.Sleep(time.Duration(r)) // 랜덤한 시간 동안 대기
	fmt.Println(n) // n 출력
}

func main() {
	for i := 0; i < 100; i++ { // 100번 반복하여
	go hello(i) // 고루틴 100개 생성
}

	fmt.Scanln()

}

고루틴 100개를 동시에 실행하면서 각 고루틴은 랜덤한 시간동안 대기합니다. rand.Intn 함수에 100을 넣으면 0부터 100까지 랜덤한 숫자를 리턴합니다. 그리고 time.Sleep 함수를 사용하여 설정한 시간동안 대기합니다. 여기서 time.Sleep 함수에 값을 넣을 때는 time.Duration 타입으로 변환해줍니다.

 

멀티코어 활용하기

Go 언어는CPU 코어를 한 개만 사용하도록 설정되어 있습니다. 다음은 시스템의 모든 CPU 코어를 사용하는 방법입니다.

package main

import (
"fmt"
"runtime"
)

func main() {
	runtime.GOMAXPROCS(runtime.NumCPU()) // CPU 개수를 구한 뒤 사용할 최대 CPU 개수 설정
	fmt.Println(runtime.GOMAXPROCS(0)) // 설정 값 출력
	s := "Hello, world!"
	for i := 0; i < 100; i++ {
		go func(n int) { // 익명 함수를 고루틴으로 실행
			fmt.Println(s, n)
		}(i)
	}

	fmt.Scanln()
}

runtime.NumCPU 함수로 현재 시스템의 CPU 코어 개수를 구한 뒤 runtime.GOMAXPROCS 함수에 설정해줍니다. 이렇게 하면 모든 CPU 코어에서 고루틴을 실행할 수 있습니다.

runtime.GOMAXPROCS 함수는 CPU 코어 개수를 구하지 않고, 특정 값을 설정해도 됩니다. 그리고 runtime.GOMAXPROCS 함수에 0을 넣으면 설정 값은 바꾸지 않으며 현재 설정 값만 리턴합니다.

 

클로저를 고루틴으로 실행하기

함수 안에서 클로저를 정의한 뒤 고루틴으로 실행할 수 있습니다. 예제의 출력 결과를 좀 더 확실하게 표현하기 위해 CPU 코어는 하나만 사용하도록 설정합니다.

package main

import (
	"fmt"
	"runtime"
)

func main() {
	runtime.GOMAXPROCS(1) // CPU를 하나만 사용
	s := "Hello, world!"
	for i := 0; i < 100; i++ {
		go func(n int) { // 익명 함수를 고루틴으로 실행(클로저)
			fmt.Println(s, n) // s와 매개변수로 받은 n 값 출력
		}(i) // 반복문의 변수는 매개변수로 넘겨줌
	}

	fmt.Scanln()

}

실행 결과

Hello, world! 0
Hello, world! 1
Hello, world! 2
.. 생략 ..
Hello, world! 97
Hello, world! 98
Hello, world! 99

클로저를 고루틴으로 실행할 때 반복문 안에서 변수 사용에 주의해야 합니다. 예제에서는 반복문으로 증가하는 i를 클로저에서 그대로 사용하지 않고, 매개변수로 넘겨주었습니다. 일반 클로저는 반복문 안에서 순서대로 실행되지만 고루틴으로 실행한 클로저는 반복문이 끝난 뒤에 고루틴이 실행됩니다.

코드를 수정하여 변수 i를 클로저의 매개변수로 넘기지 않고 fmt.Println으로 바로 출력해봅니다.

func main() {
	runtime.GOMAXPROCS(1)
	s := "Hello, world!"
	for i := 0; i < 100; i++ {
		go func() {
			fmt.Println(s, i) // 반복문의 변수를 클로저에서 바로 출력
		}()
	}

	fmt.Scanln()
}

실행 결과

Hello, world! 100
Hello, world! 100
Hello, world! 100
... 생략 ...
Hello, world! 100
Hello, world! 100
Hello, world! 100

이렇게 되면 변수 i는 0부터 99까지 증가하고, 다시 100이 되면서 반복문이 끝납니다. 고루틴은 반복문이 완전히 끝난 다음에 생성되므로 고루틴이 생성된 시점의 변수 i의 값은 100입니다. 따라서 모두 Hello, world! 100이 출력됩니다(CPU 코어를 하나만 사용했을 때의 상황입니다. CPU 코어를 여러 개 사용하면 결과는 조금 달라지지만 의도했던대로 0부터 99까지 빠짐없이 출력되지는 않습니다).

클로저를 고루틴으로 실행할 때 반복문에 의해 바뀌는 변수는 반드시 매개변수로 넘겨줍니다. 즉 매개변수로 넘겨주는 시점에 해당 변수의 값이 복사되므로 고루틴이 생성될 때 그대로 사용할 수 있습니다. 또한, CPU 코어를 하나만 사용하든 여러 개 사용하든 상관없이 반복문에 의해 바뀌는 변수는 매개변수로 넘겨주어야 합니다.

추가 해설
Go 1.4에서는 runtime.GOMAXPROCS(1)를 설정하면 고루틴이 순서대로 실행되지만 Go 1.5 이상부터는 순서대로 실행되지 않을 수도 있습니다. 이번 예제는 고루틴이 순서대로 실행되는지를 알아보는 것이 아니라 클로저를 고루틴을 실행했을 때 변수가 제대로 전달되는지를 알아보는 것이 목적입니다. Go 언어에서 고루틴의 실행 순서를 보장하려면 동기 채널 등을 사용해야 합니다.

 

서브 고루틴이 종료될 때까지 기다리기

sync패키지의 WaitGroup객체를 사용하면 스레드 종료까지 기다릴 수 있습니다.

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup // ❶ waitGroup 객체

func SumAtoB(a, b int) {
	sum := 0
	for i := a; i <= b; i++ {
		sum += i
	}

	fmt.Printf("%d부터 %d까지 합계는 %d입니다.\\n", a, b, sum)
	wg.Done() // ❸ 작업이 완료됨을 표시
}

func main() {
	wg.Add(10) // ❷ 총 작업 개수 설정
	for i := 0; i < 10; i++ {
		go SumAtoB(1, 1000000000)
	}

	wg.Wait() // ❹ 모든 작업이 완료되길 기다림.
	fmt.Println("모든 계산이 완료되었습니다.")
}

1부터 1000000000까지의 합계는 500000000500000000입니다.
1부터 1000000000까지의 합계는 500000000500000000입니다.
1부터 1000000000까지의 합계는 500000000500000000입니다.
1부터 1000000000까지의 합계는 500000000500000000입니다.
1부터 1000000000까지의 합계는 500000000500000000입니다.
1부터 1000000000까지의 합계는 500000000500000000입니다.
1부터 1000000000까지의 합계는 500000000500000000입니다.
1부터 1000000000까지의 합계는 500000000500000000입니다.
1부터 1000000000까지의 합계는 500000000500000000입니다.
1부터 1000000000까지의 합계는 500000000500000000입니다.
모든 계산이 완료되었습니다.

WaitGroup 객체의 Add()로 작업 개수를 설정하고 Done()을 작업이 완료될 때마다 호출합니다. 그리고 Wait() 부분에서 모든 작업이 완료될 때까지 기다립니다.

Mutex Lock사용 

Lock으로 공유자원을 보호하는 예제입니다.

package main

import (
	"fmt"
	"sync"
	"time"
)

var mutex sync.Mutex // ❶ 패키지 전역 변수 뮤텍스

type Account struct {
	Balance int
}

func DepositAndWithdraw(account *Account) {
	mutex.Lock()         // ❷ 뮤텍스 획득
	defer mutex.Unlock() // ❸ defer를 사용한 Unlock()
	if account.Balance < 0 {
		panic(fmt.Sprintf("Balance should not be negative value: %d", account.Balance))
	}

	account.Balance += 1000
	time.Sleep(time.Millisecond)

	account.Balance -= 1000
}

func main() {
	var wg sync.WaitGroup
	account := &Account{0}
	wg.Add(10)

	for i := 0; i < 10; i++ {
		go func() {
			for {
				DepositAndWithdraw(account)
			}

			wg.Done()
		}()

	}
	wg.Wait()

}

Deposit 함수를 보면 mutex.Lock()으로 자원 접근 권한을 획득하고 지연 호출로 함수가 종료될때 Unlock()을 실행합니다. 위 예제에서 뮤택스가 없으면 패닉이 발생합니다. Unlock()으로 항상 자원 접근 권한을 반납해야 한다는 점을 기억합시다.

다음은 데드락이 발생하는 예제입니다.

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

var wg sync.WaitGroup

func main() {
	rand.Seed(time.Now().UnixNano())
	wg.Add(2)
	fork := &sync.Mutex{} // ❶ 포크와 수저 뮤텍스
	spoon := &sync.Mutex{}
	go diningProblem("A", fork, spoon, "포크", "수저") // ❷ A는 포크 먼저
	go diningProblem("B", spoon, fork, "수저", "포크") // ❸ B는 수저 먼저
	wg.Wait()
}

func diningProblem(name string, first, second *sync.Mutex, firstName, secondName string) {
	for i := 0; i < 100; i++ {
		fmt.Printf("%s 밥을 먹으려 합니다.\\n", name)
		first.Lock() // ❹ 첫 번째 뮤텍스를 획득 시도
		fmt.Printf("%s %s 획득\\n", name, firstName)
		second.Lock() // ➎ 두 번째 뮤텍스를 획득 시도
		fmt.Printf("%s %s 획득\\n", name, secondName)
		fmt.Printf("%s 밥을 먹습니다\\n", name)
		time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)
		second.Unlock() // ➏ 뮤텍스 반납
		first.Unlock()
	}

	wg.Done()

}

B 밥을 먹으려 합니다.
B 수저 획득
B 포크 획득
B 밥을 먹습니다
A 밥을 먹으려 합니다.
A 포크 획득
A 수저 획득
A 밥을 먹습니다
B 밥을 먹으려 합니다.
A 밥을 먹으려 합니다.
B 수저 획득
A 포크 획득
fatal error: all goroutines are asleep - deadlock!
...
exit status 2

(1) 포크와 수저 뮤텍스 두 개를 만든다. (2) A는 포크를 먼저 들고 (3) B는 수저를 먼저 든다.

함수 내에서 (4) 첫 번째 뮤택스와 (5) 두 번째 뮤택스를 모두 획득한 경우에 밥을 먹고 (6) 두 뮤텍스를 반납한다.

실행결과는 A,B 둘다 밥을 먹지 못하고 무한히 대기하게 되고 Go 언어에서는 데드락을 감지하고 에러를 반환합니다. 데드락 문제는 동시성 프로그래밍에서 해결하기 힘든 난제입니다. google cloud profiler와 같은 프로파일링 툴을 이용해서 뮤텍스 검사를 할 수 있습니다.

Select 사용

다음은 select를 사용하여 다중 이벤트를 처리하는 예제입니다.

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go func() {
        time.Sleep(1 * time.Second)
        ch1 <- "Job from ch1"
    }()
    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- "Job from ch2"
    }()

    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-ch1:
            fmt.Println("Received:", msg1)
        case msg2 := <-ch2:
            fmt.Println("Received:", msg2)
        }
    }
}

select는 여러 채널 중 준비된 채널을 비차단(non-blocking)으로 선택합니다. 네트워크 요청, 타임아웃 처리, 이벤트 기반 루프 등에 필수적입니다. 다음에 소개할 채널편에서 이어서 진행하겠습니다.

 

마치며

고루틴을 사용한다고해서 컨텍스트 스위칭이 일어나지 않는 것은 아닙니다. 하지만 프로세스/스레드 단위의 컨텍스트 스위칭과 근본적으로 다른 부분이 있습니다. 바로 커널 <-> 유저 모드의 전환이 일어나지 않는 다는 점입니다. OS단 위에서 고루틴끼리의 스위칭이 일어나기 때문에 비용을 훨씬 단축할 수 있습니다. Go의 설계 철학으로 마무리하겠습니다.

"Don’t communicate by sharing memory; share memory by communicating"