go channel 详细介绍

一、介绍

go以高并发著称,而支撑这个高并发的,goroutine协程是主要原因之一。
goroutine让我们轻松实现异步,非阻塞。
但这种异步,也带来的问题是执行顺序的不确定性。
以及数据同步的问题。在这种情况下,go官方引入了channel来通信,实现数据共享。

channel是用于goroutine的数据通信

image.png
在这张图上面,我们在主协程,总共开了5个goroutine,然后每个goroutine,通过ch的channel通信共享内存,处理写以及读的数据。

1.1 语法

Channel 通过操作符 <- 执行 写入以及读取操作。

ch <- v    // 写入v到channel
v := <-ch  // 从channel读取数据。
(箭头的指向就是数据的流向)

1.2 操作

通道有发送(send)、接收(receive)和关闭(close)三种操作。
我们先定义一个channel,因为channel的空值是nil,所以必须make才能使用。

ch := make(chan int)

1.2.1 发送

将一个值发送到通道中。

ch <- 10 //把10发送到 ch 中

1.2.2 接收

从一个通道中接收值。

x := <-ch //从ch中接收值,并赋值给x
<-ch  //从ch中接收值,忽略结果

1.2.3 close()

我们通过调用内置的close函数来关闭通道。

close(ch)

1.3 channel在nil的时候panic报错,使用的时候要注意

1.3.1 关闭一个 nil 值 channel 会引发 panic

//main.关闭一个 nil 值 channel 会引发 panic。!
func TestNew(t *testing.T) {
    var ch chan struct{}
    close(ch)
}

1.3.2 关闭一个已关闭的 channel 会引发 panic

//关闭一个已关闭的 channel 会引发 panic
func TestClose(t *testing.T) {
    ch := make(chan struct{})
    close(ch)
    close(ch)
}

1.3.3 向一个已关闭的 channel 发送数据。会引发 panic

//向一个已关闭的 channel 发送数据。会引发 panic。
func TestCloseSend(t *testing.T) {
    ch := make(chan struct{})
    close(ch)
    ch <- struct{}{}
}

二、channel用来同步

我们读取一个chanel,这个channel一直到有写入的时候,才能读取,否则会一直阻塞着。

func TestSync(t *testing.T) {
    done := make(chan bool)
    go worker(done)
    //一直阻塞着,等待任务完成
    <-done
}

func worker(done chan bool) {
    time.Sleep(time.Second*10)
    // 通知任务已完成
    done <- true
}

这样也有一个问题,万一worker这个协程,有很长时间的话,就会一直阻塞,我们可以加一个保底的时间。

func TestSync(t *testing.T) {
    done := make(chan bool)
    go worker(done)
    //一直阻塞着,等待任务完成
    select {
    case <-done:
    case <-time.After(time.Second):
    }
}
func worker(done chan bool) {
    time.Sleep(time.Second * 10)
    // 通知任务已完成
    done <- true
}

我们用select改进了一下,让它有一个1秒的打底。超过1秒,就可以走出来了,不用一直阻塞着。

三、多个协程,多个channel用select来监听

如下面的代码,
开了三个channel(http1,http2,time.After),两个子协程。
用select来监听,哪个channel先返回。

import (
    "math/rand"
    "testing"
    "time"
)

func TestSelect(t *testing.T) {
    res1 := make(chan string)
    res2 := make(chan string)
    go http1(res1)
    go http2(res2)

    select {
    case v1 := <-res1:
        t.Log(v1)
    case v2 := <-res2:
        t.Log(v2)
    case <-time.After(650 * time.Millisecond):
        t.Log("650  Millisecond over, timeover")
    }
    time.Sleep(time.Second * 1)
}

func http1(res1 chan string) {
    time.Sleep(500 * time.Millisecond)
    res1 <- "res1 ok"
}

func http2(res3 chan string) {
    //[0-1000)Millisecond 随机
    rand.Seed(time.Now().UnixNano())
    time.Sleep(time.Millisecond * time.Duration(rand.Intn(1000)))
    res3 <- "res3 ok"
}

输出:

res2 ok

或者

res1 ok

看http2随机的事多少。

谢谢您的观看,欢迎关注我的公众号。

image.png

评论

暂无评论