Go์ธ์ด์ ํน์ง ์ค ํ๋๋ ๋์์ฑ์ด๋ค.
๋์์ฑ์ด๋ ํ๋ก๊ทธ๋จ์ด ์์ฐจ์ ์ธ ํ๋ฆ์ผ๋ก ์ํ๋๋ ๊ฒ์ด ์๋๋ผ ๋์์ ์ํ๋์ด ์ฒ๋ฆฌ๋๋ ๊ฒ์ ๋งํ๋ค.
Go ์ธ์ด๋ ์ด๋ฌํ ๋์์ฑ์ ์ํด ๊ณ ๋ฃจํด(goroutine)๊ณผ ์ฑ๋(channel)์ด๋ผ๋ ํค์๋๋ฅผ ์ ๊ณตํ๋ค.
Goroutine(๊ณ ๋ฃจํด) Go ๋ฐํ์์ด ๊ด๋ฆฌํ๋ Lightweight ๋ ผ๋ฆฌ์ (ํน์ ๊ฐ์์) ์ค๋ ๋์ด๋ค.
Go์์ go ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ํจ์๋ฅผ ํธ์ถํ๋ฉด ๋ฐํ์์ ์๋ก์ด ๊ณ ๋ฃจํด์ ์์ฑํ๋ค.
๊ณ ๋ฃจํด์ ๋น๋๊ธฐ์ ์ผ๋ก ํจ์ ๋ฃจํด์ ์คํํ๋ฏ๋ก, ์ฌ๋ฌ ์ฝ๋๋ฅผ ๋์์(Concurrently) ์คํํ๋๋ฐ ์ฌ์ฉ๋๋ค.
๊ณ ๋ฃจํด์ OS ์ค๋ ๋๋ณด๋ค ํจ์ฌ ๊ฐ๋ณ๊ฒ ๋น๋๊ธฐ Concurrent ์ฒ๋ฆฌ๋ฅผ ๊ตฌํํ๊ธฐ ์ํ์ฌ ๋ง๋ ๊ฒ
์ผ๋ก, ๊ธฐ๋ณธ์ ์ผ๋ก Go ๋ฐํ์์ด ์์ฒด ๊ด๋ฆฌํ๋ค.
Go ๋ฐํ์ ์์์ ๊ด๋ฆฌ๋๋ ์ฌ๋ฌ ๊ณ ๋ฃจํด๋ค์ ์ข ์ข ํ๋์ OS ์ค๋ ๋๋ก๋ ์คํ๋ ์ ์๋ค.
์ฆ, ๊ณ ๋ฃจํด๋ค์ OS ์ค๋ ๋์ 1๋1 ๋์๋์ง ์๊ณ Multiplexing์ผ๋ก ํจ์ฌ ์ ์ OS ์ค๋ ๋๋ฅผ ์ฌ์ฉํ๋ค.
๋ฉ๋ชจ๋ฆฌ ์ธก๋ฉด์์๋ OS ์ค๋ ๋๊ฐ 1๋ฉ๊ฐ๋ฐ์ดํธ์ ์คํ์ ๊ฐ๋ ๋ฐ๋ฉด,
๊ณ ๋ฃจํด์ ์ด๋ณด๋ค ํจ์ฌ ์์ ๋ช ํฌ๋ก๋ฐ์ดํธ์ ์คํ์ ๊ฐ๋๋ค(ํ์ ์ ๋์ ์ผ๋ก ์ฆ๊ฐ).
go ๋ผ๋ ํค์๋๋ฅผ ๋ถ์ฌ์ ํธ์ถํ๋ ํจ์(A)
๋ ํ์ฌ ์คํ๋๊ณ ์๋ ํจ์(B)
์ ํ๋ฆ์ด ๊ตฌ๋ถ๋์ด ๋ณ๊ฐ๋ก ๋์ํ๋ค.
์ฌ๊ธฐ์ ํธ์ถํ๋ ํจ์ A๋ ๋์์ฑ
์ ๊ฐ์ง๋ค๊ณ ํ ์ ์์ผ๋ฉฐ,
๊ณ ๋ฃจํด๋ผ๋ฆฌ์ ์์กด๊ด๊ณ๊ฐ ์์ผ๋ฏ๋ก ๊ณ ๋ฃจํด ํจ์์ ์คํ ์์๋ ํ๋ก๊ทธ๋จ์ ์ํฅ์ ๋ฏธ์น์ง ์๋๋ค.
์ฆ ๊ณ ๋ฃจํด์ ํจ์์ ์คํ์ ๋์์ ์ํํ๊ณ ์ ํ ๋ ์ฌ์ฉํ๋ค.
ํ๋ฆ์ด ๋ถ๋ฆฌ๋ ๊ณ ๋ฃจํด์ sync ํจํค์ง๋ฅผ ํตํด ์ ์ดํด์ผ ํ๋ค.
sync ํจํค์ง๋ mutual exclusion lock๊ณผ ๊ฐ์ ๋๊ธฐํ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ค.
ํํ ์ฌ์ฉํ๋ sync.Once, sync.WaitGroup ์ ๊ฒฝ์ฐ ๋ฎ์ ์์ค์ ๋๊ธฐํ๋ฅผ ์ํํ๋๋ฐ,
๋์ ์์ค์ ๋๊ธฐํ๋ฅผ ์ํด์๋ ์ดํ์ ์ค๋ช ํ ์ฑ๋์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค๊ณ ๊ณต์๋ฌธ์์์ ๋ฐํ๊ณ ์๋ค.
mutual exclusion lock : ์ํธ ๋ฐฐ์ ์ ๊ธ, ๊ณต์ ๋ถ๊ฐ๋ฅํ ์์์ ๋์ ์ฌ์ฉ์ ํผํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ ์๊ณ ๋ฆฌ์ฆ
์ฑ๋์ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ํต๋ก ์ญํ ์ ํ๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค.
์ฑ๋์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ ๋ฝ์๋ด๋ ํํ๋ก ์ฌ์ฉํ๋ฉฐ ํํ ์๋ก ๋ค๋ฅธ ๊ณ ๋ฃจํด ์ฌ์ด์ ํต์ ์ ์ํด ์ฐ์ธ๋ค.
Go๋ ์ฑ๋์ ๊ธฐ๋ณธ ์๋ฃํ์ผ๋ก ์ ๊ณตํ๋ฏ๋ก, ๋ค๋ฅธ ํจํค์ง๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์์ด ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
์ฑ๋์ ์ฌ์ฉํ๊ธฐ ์ํด์๋ make ํจ์๋ฅผ ํตํด ๋ฏธ๋ฆฌ ์์ฑํด์ผ ํ๋ฉฐ,
์์ฑ ์ chan ์ด๋ผ๋ ํค์๋์ ํจ๊ป ํด๋น ์ฑ๋์์ ์ฃผ๊ณ ๋ฐ์ ์๋ฃํ์ ์ ์ํ๋ค.
c1 := make(chan int) // ์ ์ ์์ฑ๋ c1
var chan int c2 = c1 // ์ ์ฑ๋ ๋ณ์ c2์ c1๋ฅผ ํ ๋น
var chan<- int c3 = c1 // send ์ ์ฉ ์ฑ๋ c3
var <-chan int c4 = c1 // receive ์ ์ฉ ์ฑ๋ c4
์ฑ๋์ ๋ด๋ถ์์ ์์ ์์ ์ก์ ์๊ฐ ์๋ก ๊ธฐ๋ค๋ฆฌ๋ ์์ฑ์ ๊ฐ์ง๋ค.
์ฆ ์ก์ ๊ณ ๋ฃจํด๊ณผ ์์ ๊ณ ๋ฃจํด์ด ๋์์ ๋ณด๋ด๊ณ ๋ฐ์ ์ค๋น๊ฐ ๋์ด ์์ด์ผ ์ฌ๋ฐ๋ฅด๊ฒ ๋์ํ๋ค.
์ด๋ฌํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด Go๋ ์ฑ๋ ๋ฒํผ๋ง ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ค.
package main
import "fmt"
func main() {
c := make(chan int, 5) // ๋ฒํผ๊ฐ 5์ธ ์ ์ํ ์ฑ๋
go func() {
c <- 111
c <- 222
c <- 333
}()
i := <-c
fmt.Println(i)
}
๋ฒํผ๊ฐ ์๋ ์ฑ๋์ ์ฑ๋์ ๋ฒํผ ํฌ๊ธฐ๋ฅผ ์ง์ ํจ์ผ๋ก์จ ๋ฒํผ๊ฐ ๊ฐ๋์ฐจ๊ธฐ ์ ๊น์ง๋ ์์ ๊ณ ๋ฃจํด์ด ์ค๋น๋์ง ์์๋
์ก์ ๊ณ ๋ฃจํด์ด ์ฑ๋์ ๋ฏธ๋ฆฌ ๋ฐ์ดํฐ๋ฅผ ์ ์กํ ์ ์๋ค.
๋ฐ๋ผ์ ์ก์ ๊ณ ๋ฃจํด์ ์์ ๊ณ ๋ฃจํด์ ์ค๋น์ฌ๋ถ์ ์๊ด์์ด ๋ฏธ๋ฆฌ ์ ์กํ๊ณ ๋ค๋ฅธ ์ผ์ ๋ฐ๋ก ์ํํ ์ ์๋ค.
๊ทธ๋ฌ๋ ๋ฒํผ๊ฐ ์๋ ์ฑ๋์ด ์ธ์ ๋ ์ข์ ๊ฒ์ ์๋๋ค.
๋ฒํผ๊ฐ ๊ฐ๋ ์ฐฌ ๊ฒฝ์ฐ ์ก์ ๊ณ ๋ฃจํด์ด ๋ฐ์ดํฐ๋ฅผ ์ ์กํ๋ค๋ฉด ์๋ฌ๊ฐ ๋ฐ์ํ์ฌ ๊ณ ๋ฃจํด ๋์์ด ๋ฉ์ถฐ๋ฒ๋ฆฐ๋ค.
๊ฒฝ์ฐ์ ๋ฐ๋ผ์๋ ์น๋ช ์ ์ธ ๋ฌธ์ ๋ก ์ด์ด์ง ์ ์๊ธฐ ๋๋ฌธ์,
์ฒ์์๋ ๋ฒํผ๊ฐ ์๋ ์ฑ๋๋ก ์ต์ ํ๋ ์ฝ๋๋ฅผ ์์ฑํ๋, ํ์์ ๋ฐ๋ผ์ ๋ฒํผ์ ํฌ๊ธฐ๋ฅผ ์กฐ์ ํด์ฃผ๋ ๊ฒ์ด ์ข๋ค.