단일 스레딩은 Go 언어의 기능인가요?

싱글 스레딩은 Go 언어의 기능이 아니며 Go 언어는 멀티 스레드입니다. Golang의 스레드 모델은 MPG 모델입니다. 전반적으로 Go 프로세스와 커널 스레드는 다대다 대응을 가지므로 Go는 다중 스레드 모드에 있어야 합니다. M과 커널 스레드는 1대 1에 대응하고 여러 G는 여러 M에 대응합니다. 이에 따라 P는 컨텍스트 리소스를 나타냅니다.

이 튜토리얼의 운영 환경: Windows 7 시스템, GO 버전 1.18, Dell G3 컴퓨터.

싱글 스레딩은 Go 언어의 기능이 아니며 Go 언어는 멀티 스레드입니다. 싱글쓰레드라면 아직도 쑥스럽네요. 멀티코어 시대에 높은 동시성을 위해 탄생한 언어라고요?

Golang의 스레드 모델은 MPG 모델입니다. 전체적으로 Go 프로세스와 커널 스레드는 다대다 대응을 가지므로 우선 멀티 스레드여야 합니다. 그 중 M은 커널 스레드 1:1에 해당하고, G는 다중 M에 해당합니다. P는 컨텍스트 리소스를 의미하므로 별로 말할 것도 없습니다. M(또는 커널 스레드) 수는 언제 증가합니까? 즉, 현재 M 개수로 현재 G를 모두 이동하도록 예약할 수 없는 경우 새 M을 사용하여 이를 처리합니다.

Go 동시성(멀티스레딩)

어떤 사람들은 Go를 21세기 C 언어와 비교합니다. 첫 번째는 Go 언어가 디자인이 단순하기 때문입니다. 두 번째는 21세기에 가장 중요한 것입니다. 병렬 프로그래밍이며 언어 수준에서 이동합니다. 이는 병렬성을 지원합니다.

goroutine

goroutine은 Go 병렬 디자인의 핵심입니다. 최종 분석에서 고루틴은 실제로 스레드이지만 12개의 고루틴이 하단에 5~6개의 스레드에 반영될 수 있습니다. Go 언어는 이러한 고루틴 간의 메모리 공유를 실현하는 데 도움이 됩니다. 고루틴을 실행하는 데는 매우 적은 스택 메모리(약 4~5KB)가 필요하며 물론 해당 데이터에 따라 확장됩니다. 이로 인해 수천 개의 동시 작업을 동시에 실행할 수 있습니다. 고루틴은 스레드보다 사용하기 쉽고 효율적이며 가볍습니다.

Goroutine은 Go의 런타임으로 관리되는 스레드 관리자입니다. 고루틴은 실제로는 일반 함수인 go 키워드를 통해 구현됩니다. go关键字实现了，其实就是一个普通的函数。

go hello(a, b, c)

通过关键字go就启动了一个goroutine。我们来看一个例子

package main

import (
    "fmt"
    "runtime"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        runtime.Gosched()
        fmt.Println(s)
    }
}

func main() {
    go say("world") //开一个新的Goroutines执行
    say("hello") //当前Goroutines执行
}

// 以上程序执行后将输出：
// hello
// world
// hello
// world
// hello
// world
// hello
// world
// hello

我们可以看到go关键字很方便的就实现了并发编程。 上面的多个goroutine运行在同一个进程里面，共享内存数据，不过设计上我们要遵循：不要通过共享来通信，而要通过通信来共享。

runtime.Gosched()表示让CPU把时间片让给别人,下次某个时候继续恢复执行该goroutine。

默认情况下，调度器仅使用单线程，也就是说只实现了并发。想要发挥多核处理器的并行，需要在我们的程序中显式调用 runtime.GOMAXPROCS(n) 告诉调度器同时使用多个线程。GOMAXPROCS 设置了同时运行逻辑代码的系统线程的最大数量，并返回之前的设置。如果n < 1，不会改变当前设置。以后Go的新版本中调度得到改进后，这将被移除。

channels

goroutine运行在相同的地址空间，因此访问共享内存必须做好同步。那么goroutine之间如何进行数据的通信呢，Go提供了一个很好的通信机制channel。channel可以与Unix shell 中的双向管道做类比：可以通过它发送或者接收值。这些值只能是特定的类型：channel类型。定义一个channel时，也需要定义发送到channel的值的类型。注意，必须使用make 创建channel：

ci := make(chan int)
cs := make(chan string)
cf := make(chan interface{})

channel通过操作符<-

ch <- v    // 发送v到channel ch.
v := <-ch  // 从ch中接收数据，并赋值给v

go 키워드를 통해 고루틴을 시작하세요. 예제를 살펴보겠습니다

package main

import "fmt"

func sum(a []int, c chan int) {
    total := 0
    for _, v := range a {
        total += v
    }
    c <- total  // send total to c
}

func main() {
    a := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(a[:len(a)/2], c)
    go sum(a[len(a)/2:], c)
    x, y := <-c, <-c  // receive from c

    fmt.Println(x, y, x + y)
}

go 키워드를 사용하면 동시 프로그래밍을 쉽게 구현하는 것을 볼 수 있습니다. 위의 여러 고루틴은 동일한 프로세스에서 실행되며 메모리 데이터를 공유합니다. 그러나 우리는 공유를 통해 통신하지 않고 통신을 통해 공유한다는 설계를 따라야 합니다.

runtime.Gosched()는 CPU가 타임 슬라이스를 다른 사람에게 포기하고 다음 번에 고루틴 실행을 계속 재개하도록 하는 것을 의미합니다. 기본적으로 스케줄러는 단일 스레드만 사용하므로 동시성만 구현됩니다. 멀티 코어 프로세서의 병렬성을 활용하려면 프로그램에서 런타임.GOMAXPROCS(n)를 명시적으로 호출하여 스케줄러에게 동시에 여러 스레드를 사용하도록 지시해야 합니다. GOMAXPROCS는 논리 코드를 동시에 실행할 수 있는 최대 시스템 스레드 수를 설정하고 이전 설정을 반환합니다. n < 1이면 현재 설정이 변경되지 않습니다. 이는 Go의 향후 버전에서 일정 관리가 개선되면 제거될 예정입니다.

channels

🎜🎜🎜goroutine은 동일한 주소 공간에서 실행되므로 공유 메모리에 대한 액세스가 동기화되어야 합니다. 그렇다면 고루틴 간에 데이터를 통신하는 방법은 무엇입니까? Go는 좋은 통신 메커니즘 채널을 제공합니다. 채널은 Unix 셸의 양방향 파이프와 비교할 수 있습니다. 채널을 통해 값을 보내거나 받을 수 있습니다. 이 값은 특정 유형, 즉 채널 유형만 될 수 있습니다. 채널을 정의할 때 채널로 전송되는 값의 유형도 정의해야 합니다. 채널은 make를 사용하여 생성되어야 합니다. 🎜

ch := make(chan type, value)

value == 0 ! 无缓冲（阻塞）
value > 0 ! 缓冲（非阻塞，直到value 个元素）

🎜채널은 <- 연산자를 통해 데이터를 수신하고 보냅니다. 🎜

package main

import "fmt"

func main() {
    c := make(chan int, 2)//修改2为1就报错，修改2为3可以正常运行
    c <- 1
    c <- 2
    fmt.Println(<-c)
    fmt.Println(<-c)
}
    //修改为1报如下的错误:
    //fatal error: all goroutines are asleep - deadlock!

🎜다음 예를 적용합니다. 🎜

package main

import (
    "fmt"
)

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

func main() {
    c := make(chan int, 10)
    go fibonacci(cap(c), c)
    for i := range c {
        fmt.Println(i)
    }
}

🎜기본적으로 채널은 반대쪽 끝이 준비되지 않은 한 데이터를 주고받을 때 차단되므로 명시적인 잠금 없이도 고루틴 동기화가 더 쉬워집니다. 소위 차단이란 (값 := <-ch) 읽으면 데이터가 수신될 때까지 차단된다는 의미입니다. 둘째, 데이터를 읽을 때까지 모든 전송(ch<-5)이 차단됩니다. 버퍼링되지 않은 채널은 여러 고루틴 간의 동기화를 위한 훌륭한 도구입니다. 🎜🎜🎜🎜🎜🎜버퍼 채널🎜🎜🎜🎜위에서 기본 비캐시 유형 채널을 소개했지만 Go를 사용하면 채널의 버퍼 크기를 지정할 수도 있습니다. 즉, 채널 요소 수는 매우 간단합니다. 저장할 수 있습니다. ch:= make(chan bool, 4)는 4개의 요소를 저장할 수 있는 bool 유형 채널을 생성합니다. 이 채널에서는 처음 4개 요소를 차단하지 않고 쓸 수 있습니다. 5번째 요소가 작성되면 다른 고루틴이 채널에서 일부 요소를 읽어 공간을 확보할 때까지 코드가 차단됩니다. 🎜

ch := make(chan type, value)

value == 0 ! 无缓冲（阻塞）
value > 0 ! 缓冲（非阻塞，直到value 个元素）
我们看一下下面这个例子，你可以在自己本机测试一下，修改相应的value值
package main

import "fmt"

func main() {
    c := make(chan int, 2)//修改2为1就报错，修改2为3可以正常运行
    c <- 1
    c <- 2
    fmt.Println(<-c)
    fmt.Println(<-c)
}
    //修改为1报如下的错误:
    //fatal error: all goroutines are asleep - deadlock!
Range和Close
上面这个例子中，我们需要读取两次c，这样不是很方便，Go考虑到了这一点，所以也可以通过range，像操作slice或者map一样操作缓存类型的channel，请看下面的例子
package main

import (
    "fmt"
)

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

func main() {
    c := make(chan int, 10)
    go fibonacci(cap(c), c)
    for i := range c {
        fmt.Println(i)
    }
}
for i := range c能够不断的读取channel里面的数据，直到该channel被显式的关闭。上面代码我们看到可以显式的关闭channel，生产者通过内置函数close关闭channel。关闭channel之后就无法再发送任何数据了，在消费方可以通过语法v, ok := <-ch测试channel是否被关闭。如果ok返回false，那么说明channel已经没有任何数据并且已经被关闭。

记住应该在生产者的地方关闭channel，而不是消费的地方去关闭它，这样容易引起panic
另外记住一点的就是channel不像文件之类的，不需要经常去关闭，只有当你确实没有任何发送数据了，或者你想显式的结束range循环之类的

Select
我们上面介绍的都是只有一个channel的情况，那么如果存在多个channel的时候，我们该如何操作呢，Go里面提供了一个关键字select，通过select可以监听channel上的数据流动。
select默认是阻塞的，只有当监听的channel中有发送或接收可以进行时才会运行，当多个channel都准备好的时候，select是随机的选择一个执行的。
package main

import "fmt"

func fibonacci(c, quit chan int) {
    x, y := 1, 1
    for {
        select {
        case c <- x:
            x, y = y, x + y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
    fibonacci(c, quit)
}
在select里面还有default语法，select其实就是类似switch的功能，default就是当监听的channel都没有准备好的时候，默认执行的（select不再阻塞等待channel）。
select {
case i := <-c:
    // use i
default:
    // 当c阻塞的时候执行这里
}
超时
有时候会出现goroutine阻塞的情况，那么我们如何避免整个程序进入阻塞的情况呢？我们可以利用select来设置超时，通过如下的方式实现：
func main() {
    c := make(chan int)
    o := make(chan bool)
    go func() {
        for {
            select {
                case v := <- c:
                    println(v)
                case <- time.After(5 * time.Second):
                    println("timeout")
                    o <- true
                    break
            }
        }
    }()
    <- o
}
runtime goroutine
runtime包中有几个处理goroutine的函数：


Goexit
退出当前执行的goroutine，但是defer函数还会继续调用


Gosched
让出当前goroutine的执行权限，调度器安排其他等待的任务运行，并在下次某个时候从该位置恢复执行。


NumCPU
返回 CPU 核数量


NumGoroutine
返回正在执行和排队的任务总数


GOMAXPROCS
用来设置可以并行计算的CPU核数的最大值，并返回之前的值。


【相关推荐：Go视频教程、编程教学】
위 내용은 단일 스레딩은 Go 언어의 기능인가요?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!