GoLang의 코루틴에 대한 자세한 그래픽 및 텍스트 설명

Coroutine은 Go 런타임에서 관리하는 Go 언어의 경량 스레드 구현입니다.

함수 호출 앞에 go 키워드를 추가하면 호출이 새로운 고루틴에서 동시에 실행됩니다. 호출된 함수가 반환되면 이 고루틴도 자동으로 종료됩니다. 이 함수에 반환 값이 있으면 반환 값이 삭제된다는 점에 유의하세요.

먼저 다음 예를 살펴보세요.

func Add(x, y int) {
    z := x + y
    fmt.Println(z)
}

func main() {
    for i:=0; i<10; i++ {
        go Add(i, i)
    }
}

위 코드를 실행하면 화면에 아무것도 인쇄되지 않고 프로그램이 종료되는 것을 확인할 수 있습니다.

위의 예에서 main() 함수는 10개의 고루틴을 시작한 후 반환됩니다. 이때 프로그램은 종료되며 Add()를 실행하는 시작된 고루틴은 실행할 시간이 없습니다. 우리는 main() 함수가 반환하기 전에 모든 고루틴이 종료될 때까지 기다리기를 원하지만 모든 고루틴이 종료되었는지 어떻게 알 수 있습니까? 이로 인해 여러 고루틴 간의 통신 문제가 발생합니다.

엔지니어링에는 공유 메모리와 메시지라는 두 가지 가장 일반적인 동시 통신 모델이 있습니다.

아래 예시를 보세요. 10개의 고루틴이 변수 카운터를 공유합니다. 각 고루틴이 실행된 후 카운터 값이 1씩 증가합니다. 10개의 고루틴이 동시에 실행되기 때문에 잠금도 도입합니다. 코드의 잠금 변수. main() 함수에서는 for 루프를 사용하여 지속적으로 카운터 값을 확인하는데, 그 값이 10에 도달하면 이 때 모든 고루틴이 실행되었음을 의미하고 프로그램이 종료됩니다.

package main
import (
    "fmt"
    "sync"
    "runtime"
)

var counter int = 0

func Count(lock *sync.Mutex) {
    lock.Lock()
    counter++
    fmt.Println("counter =", counter)
    lock.Unlock()
}


func main() {

    lock := &sync.Mutex{}

    for i:=0; i<10; i++ {
        go Count(lock)
    }

    for {
        lock.Lock()

        c := counter

        lock.Unlock()

        runtime.Gosched()　　　　// 出让时间片

        if c >= 10 {
            break
        }
    }
}

위의 예에서는 잠금 변수(공유 메모리의 일종)를 사용하여 코루틴을 동기화합니다. 실제로 Go 언어는 주로 메시지 메커니즘(채널)을 통신 모델로 사용합니다.

channel

메시징 메커니즘은 각 동시 단위를 독립적인 개체로 간주합니다. 각각에는 고유한 변수가 있지만 이러한 변수는 서로 다른 동시 단위 간에 공유되지 않습니다. 각 동시 단위에는 하나의 입력 및 출력, 즉 메시지만 있습니다.

Channel은 언어 수준에서 Go 언어가 제공하는 고루틴 간의 통신 방법으로, 채널을 사용하여 여러 고루틴 간에 메시지를 전달할 수 있습니다. 채널은 프로세스 내 통신 방법이므로 채널을 통해 객체를 전달하는 프로세스는 함수 호출 시 매개변수 전달 동작과 일치합니다. 예를 들어 포인터도 전달할 수 있습니다.
Channel은 유형과 관련되어 있습니다. 채널은 한 가지 유형의 값만 전달할 수 있습니다. 이 유형은 채널을 선언할 때 지정해야 합니다.

채널 선언 형식은 다음과 같습니다.

var chanName chan ElementType

예를 들어 int 유형을 전달하는 채널을 선언합니다.

var ch chan int

Usebuilt- in make() 함수는 채널을 정의합니다:

ch := make(chan int)

채널 사용에서 가장 일반적인 사용에는 쓰기 및 읽기가 포함됩니다.

// 将一个数据value写入至channel，这会导致阻塞，直到有其他goroutine从这个channel中读取数据
ch <- value

// 从channel中读取数据，如果channel之前没有写入数据，也会导致阻塞，直到channel中被写入数据为止
value := <-ch

기본적으로 채널의 수신 및 읽기는 다음과 같습니다. 읽기 상대방이 준비되지 않으면 전송이 차단됩니다.

버퍼링된 채널을 만들 수도 있습니다:

c := make(chan int, 1024)

// 从带缓冲的channel中读数据
for i:=range c {
　　...
}

이때, 리더나 라이터가 없더라도 크기가 1024인 int 유형의 채널을 만듭니다. 버퍼가 채워질 때까지 차단하지 않고 채널에 계속 쓸 수도 있습니다.

더 이상 사용하지 않는 채널을 폐쇄할 수 있습니다:

close(ch)

채널은 제작자의 장소에서 폐쇄되어야 하며, 소비자의 장소에서 폐쇄되면 쉽게 폐쇄됩니다. 원인 패닉

닫힌 채널에서 수신 작업(<-ch)을 수행하면 항상 즉시 반환되며 반환 값은 해당 유형의 0 값입니다.

이제 채널을 사용하여 위의 예를 다시 작성합니다:

func Count(ch chan int) {
    ch <- 1
    fmt.Println("Counting")
}

func main() {

    chs := make([] chan int, 10)

    for i:=0; i<10; i++ {
        chs[i] = make(chan int)
        go Count(chs[i])
    }

    for _, ch := range(chs) {
        <-ch
    }
}

이 예에서는 10개의 채널을 포함하는 배열이 정의되고 배열의 각 채널은 10개의 다른 고루틴에 할당됩니다. . 각 고루틴이 완료된 후 데이터가 고루틴에 기록됩니다. 이 작업은 채널을 읽을 때까지 차단됩니다.

모든 고루틴이 시작된 후 10개의 채널에서 순차적으로 데이터를 읽습니다. 이 작업은 해당 채널이 데이터를 쓰기 전에도 차단됩니다. 이러한 방식으로 채널은 잠금과 유사한 기능을 구현하는 데 사용되며 모든 고루틴이 완료된 후에만 main()이 반환되도록 보장합니다.

또한 채널 변수를 함수에 전달할 때 단방향 채널 변수로 지정하여 함수에서 이 채널에 대한 작업을 제한할 수 있습니다.

단방향 채널 변수 선언:

var ch1 chan int  　　　　// 普通channel
var ch2 chan <- int 　　 // 只用于写int数据
var ch3 <-chan int 　　 // 只用于读int数据

유형 변환을 통해 채널을 단방향으로 변환할 수 있습니다:

ch4 := make(chan int)
ch5 := <-chan int(ch4)   // 单向读
ch6 := chan<- int(ch4)  //单向写

One-way 채널 이 함수는 코드에서 "최소 권한의 원칙"을 따르는 데 사용되는 C++의 const 키워드와 다소 유사합니다.

예를 들어 함수에서 단방향 읽기 채널을 사용하는 경우:

func Parse(ch <-chan int) {
    for value := range ch {
        fmt.Println("Parsing value", value) 
    }
}

네이티브 유형으로 다음과 같이 채널 자체를 채널을 통해 전달할 수도 있습니다. 스트리밍 처리 구조 ：

type PipeData struct {
    value int
    handler func(int) int
    next chan int
}

func handle(queue chan *PipeData) {
    for data := range queue {
        data.next <- data.handler(data.value)
    }
}

select

UNIX에서는 select() 함수를 사용하여 모니터링합니다. 설명자 세트, 이 메커니즘은 종종 동시성 소켓 서버 프로그램을 구현하는 데 사용됩니다. Go 언어는 비동기 IO 문제를 처리하는 데 사용되는 select 키워드를 언어 수준에서 직접 지원합니다. 일반적인 구조는 다음과 같습니다.

select {
    case <- chan1:
    // 如果chan1成功读到数据
    
    case chan2 <- 1:
    // 如果成功向chan2写入数据

    default:
    // 默认分支
}

select는 기본적으로 차단되며 수행만 가능합니다. 모니터링되는 채널에 송신 또는 수신이 있을 때 여러 채널이 준비되면 무작위로 하나를 선택하여 실행합니다.

Go语言没有对channel提供直接的超时处理机制，但我们可以利用select来间接实现，例如：

timeout := make(chan bool, 1)

go func() {
    time.Sleep(1e9)
    timeout <- true
}()

switch {
    case <- ch:
    // 从ch中读取到数据

    case <- timeout:
    // 没有从ch中读取到数据，但从timeout中读取到了数据
}

这样使用select就可以避免永久等待的问题，因为程序会在timeout中获取到一个数据后继续执行，而无论对ch的读取是否还处于等待状态。

并发

早期版本的Go编译器并不能很智能的发现和利用多核的优势，即使在我们的代码中创建了多个goroutine，但实际上所有这些goroutine都允许在同一个CPU上，在一个goroutine得到时间片执行的时候其它goroutine都会处于等待状态。

实现下面的代码可以显式指定编译器将goroutine调度到多个CPU上运行。

import "runtime"...
runtime.GOMAXPROCS(4)

PS：runtime包中有几个处理goroutine的函数，

调度

Go调度的几个概念：

M：内核线程；

G：go routine，并发的最小逻辑单元，由程序员创建；

P：处理器，执行G的上下文环境，每个P会维护一个本地的go routine队列；

 除了每个P拥有一个本地的go routine队列外，还存在一个全局的go routine队列。

具体调度原理：

1、P的数量在初始化由GOMAXPROCS决定；

2、我们要做的就是添加G；

3、G的数量超出了M的处理能力，且还有空余P的话，runtime就会自动创建新的M；

4、M拿到P后才能干活，取G的顺序：本地队列>全局队列>其他P的队列，如果所有队列都没有可用的G，M会归还P并进入休眠；

一个G如果发生阻塞等事件会进行阻塞，如下图：

G发生上下文切换条件：

系统调用；

读写channel；

gosched主动放弃，会将G扔进全局队列；

如上图，一个G发生阻塞时，M0让出P，由M1接管其任务队列；当M0执行的阻塞调用返回后，再将G0扔到全局队列，自己则进入睡眠（没有P了无法干活）；

위 내용은 GoLang의 코루틴에 대한 자세한 그래픽 및 텍스트 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!