Go routine

[robert-min]

Go routine

• 고루틴은 경량 스레드로 함수나 명령을 동시에 실행할 때 사용
• 일반적으로 멀티 스레드의 경우 컨테스트 스위칭 비용이 발생하기 때문에 문제
• 고루틴은 CPU 코어마다 OS 스레드를 하나만 할당해서 사용하기 때문에 컨텍스트 스위칭 비용이 발생하지 않음

sync.WaitGroup

• 고루틴이 종료될때까지 대기

package main

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

var wg sync.WaitGroup

func PrintHangle() {
    hanguls := []rune{'가', '나', '다', '라'}
    for _, v := range hanguls {
        time.Sleep(300 * time.Millisecond)
        fmt.Printf("%c ", v)
    }
    wg.Done()
}

func PrintNumbers() {
    for i := 1; i <= 5; i++ {
        time.Sleep(400 * time.Millisecond)
        fmt.Printf("%d ", i)
    }
    wg.Done()
}

func main() {
    wg.Add(2)
    go PrintHangle()
    go PrintNumbers()

    wg.Wait()
}

[robert-min]

고루팀 사용시 동일한 메모리 자원 접근 시 문제

• 동시성 프로그램의 문제는 동일한 메모리 자원에 여러 고루틴이 접근할 때 발생
• 이 문제를 해결하기 위해 뮤텍스 사용

package main

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

var mutex sync.Mutex

type Account struct {
    Balance int
}

func DepositAndWithdraw(account *Account) {
    // mutex 획득
    mutex.Lock()
    defer mutex.Unlock()

    if account.Balance < 0 {
        panic(fmt.Sprintf("Balance sould 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()

}

• 뮤텍스가 꼬이지 않도록 좁은 범위에서 데드락에 걸리지 않는지 철저히 확인해서 사용 필요

[robert-min]

Channel

• 채널은 고루틴끼리 메시지를 전달할 수 있는 메시지 큐

• 일반적으로 채널을 생성하면 크기가 0인 채널을 만들고, 데이터를 담아둘 곳이 없기 때문에 수신자가 올때까지 대기

• 버퍼를 가진 채널은 데이터를 보관할 수 있는 메모리 영역을 가짐

  var chan string messages = make(chan string, 2)

package main

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

func square(wg *sync.WaitGroup, ch chan int) {
    for n := range ch {
        fmt.Printf("Square: %d\n", n*n)
        time.Sleep(time.Second)
    }
    wg.Done()
}

func main() {

    var wg sync.WaitGroup
    ch := make(chan int)

    wg.Add(1)
    go square(&wg, ch)

    for i := 0; i < 10; i++ {
        ch <- i * 2
    }
    // 데이터를 모두 넣고 필요 없어진 채널을 닫음
    close(ch)
    wg.Wait()

}

[robert-min]

Chan Select

package main

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

func square(wg *sync.WaitGroup, ch chan int, quit chan bool) {
    for {
        select {
        case n := <-ch:
            fmt.Printf("Square: %d\n", n*n)
            time.Sleep(time.Second)
        case <-quit:
            wg.Done()
            return
        }
    }
}

func main() {
    var wg sync.WaitGroup
    ch := make(chan int)
    quit := make(chan bool)

    wg.Add(1)
    go square(&wg, ch, quit)

    for i := 0; i < 10; i++ {
        ch <- i * 2
    }

    quit <- true
    wg.Wait()
}

[robert-min]

Context

• 고루틴 작업 진행할 때 작업 가능 시간, 작업 취소 등의 조건을 지시할 수 있는 작업 명세서 역할

작업 취소가 가능한 컨텍스트

package main

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

var wg sync.WaitGroup

func PrintEverySecond(ctx context.Context) {
    tick := time.Tick(time.Second)
    for {
        select {
        case <-ctx.Done():
            wg.Done()
            return
        case <-tick:
            fmt.Println("Tick")
        }
    }
}

func main() {
    wg.Add(1)
    // context 생성
    ctx, cancel := context.WithCancel(context.Background())
    go PrintEverySecond(ctx)
    time.Sleep(5 * time.Second)
    cancel()

    wg.Wait()

}

특정 값을 설정한 컨택스트

package main

import (
    "context"
    "fmt"
    "sync"
)

var wg sync.WaitGroup

func squre(ctx context.Context) {
    if v := ctx.Value("number"); v != nil {
        n := v.(int)
        fmt.Printf("Squre: %d", n*n)
    }
    wg.Done()
}

func main() {
    wg.Add(1)
    // context 생성
    ctx := context.WithValue(context.Background(), "number", 9)
    go squre(ctx)

    wg.Wait()

}