Golang에서 고루틴과 채널의 고급 사용법

Golang에서 고루틴과 채널의 고급 사용법

Golang의 동시 프로그래밍에서 고루틴과 채널은 매우 중요한 두 가지 개념입니다. 고루틴은 동시에 실행할 수 있는 경량 스레드인 반면, 채널은 고루틴 간의 통신 메커니즘입니다. 이 글에서는 Golang의 고루틴과 채널의 고급 사용법을 살펴보고 코드 예제를 통해 설명하겠습니다.

1. 고루틴의 고급 사용법

1. 고루틴의 다중화는 select 문을 통해 달성할 수 있습니다. 아래 코드 예제에서는 피보나치 수열과 계승을 각각 계산하기 위해 두 개의 고루틴을 생성합니다. select 문을 통해 두 개의 고루틴이 동시에 완료되기를 기다리고 계산 결과를 인쇄할 수 있습니다.

package main

import (
    "fmt"
)

func fibonacci(n int, c chan<- int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    close(c)
}

func factorial(n int, c chan<- int) {
    result := 1
    for i := 1; i <= n; i++ {
        result *= i
    }
    c <- result
    close(c)
}

func main() {
    fibChan := make(chan int)
    factChan := make(chan int)

    go fibonacci(10, fibChan)
    go factorial(5, factChan)

    for {
        select {
        case fib, ok := <-fibChan:
            if ok {
                fmt.Println("Fibonacci:", fib)
            } else {
                fibChan = nil
            }

        case fact, ok := <-factChan:
            if ok {
                fmt.Println("Factorial:", fact)
            } else {
                factChan = nil
            }

        default:
            if fibChan == nil && factChan == nil {
                return
            }
        }
    }
}

2. WaitGroup을 통해 고루틴 완료를 기다릴 수 있습니다. WaitGroup은 고루틴 그룹이 완료될 때까지 기다리는 데 사용할 수 있는 카운터입니다. 아래 코드 예제에서는 피보나치 수열과 계승을 각각 계산하기 위해 두 개의 고루틴을 생성합니다. sync.WaitGroup을 사용하면 두 개의 고루틴이 동시에 완료될 때까지 기다릴 수 있습니다.

package main

import (
    "fmt"
    "sync"
)

func fibonacci(n int, c chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    close(c)
}

func factorial(n int, c chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    result := 1
    for i := 1; i <= n; i++ {
        result *= i
    }
    c <- result
    close(c)
}

func main() {
    fibChan := make(chan int)
    factChan := make(chan int)
    var wg sync.WaitGroup

    wg.Add(2)

    go fibonacci(10, fibChan, &wg)
    go factorial(5, factChan, &wg)

    go func() {
        wg.Wait()
        close(fibChan)
        close(factChan)
    }()

    for {
        select {
        case fib, ok := <-fibChan:
            if ok {
                fmt.Println("Fibonacci:", fib)
            } else {
                fibChan = nil
            }

        case fact, ok := <-factChan:
            if ok {
                fmt.Println("Factorial:", fact)
            } else {
                factChan = nil
            }

        default:
            if fibChan == nil && factChan == nil {
                return
            }
        }
    }
}

2. 채널의 고급 사용

1. 버퍼 크기를 설정하여 채널의 차단 동작을 제어할 수 있습니다. 기본적으로 채널은 버퍼링되지 않습니다. 즉, 상대방이 준비될 때까지 전송 및 수신이 차단됩니다. make 함수의 두 번째 매개변수를 통해 버퍼 크기를 설정할 수 있습니다. 다음 코드 예제에서는 버퍼 크기가 3인 채널을 만들고 여기에 3개의 값을 보냅니다. 버퍼가 가득 차지 않으므로 전송이 차단되지 않습니다.

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3

    fmt.Println(<-ch)
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

2. 범위 키워드를 통해 채널을 반복할 수 있습니다. range 키워드를 사용하면 채널의 값을 반복할 수 있으며 채널이 닫히면 반복이 자동으로 종료됩니다. 다음 코드 예시에서는 카운터 고루틴을 생성하고 버퍼링되지 않은 채널에 5개의 값을 보냅니다. 메인 함수에서는 range 키워드를 사용하여 채널의 값을 반복하고 인쇄합니다. 채널이 닫히면 범위 루프가 자동으로 종료됩니다.

package main

import (
    "fmt"
    "time"
)

func counter(ch chan<- int) {
    for i := 1; i <= 5; i++ {
        ch <- i
        time.Sleep(time.Second)
    }
    close(ch)
}

func main() {
    ch := make(chan int)
    go counter(ch)

    for val := range ch {
        fmt.Println(val)
    }
}

요약하자면 Golang의 고루틴과 채널은 강력하고 유연한 동시 프로그래밍 기능을 제공합니다. 우리는 select 문, WaitGroup, 버퍼 및 범위 키워드와 같은 고급 사용을 통해 고루틴 및 채널의 동작을 더 효과적으로 제어할 수 있습니다. 이 기사에 제공된 코드 예제가 독자가 이러한 고급 사용법을 더 잘 이해하고 적용하는 데 도움이 되기를 바랍니다.

위 내용은 Golang에서 고루틴과 채널의 고급 사용법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!