go chan基本使用详解（gokke使用说明）学到了

随心笔谈2年前发布编辑

165 0

🌐 经济型：买域名、轻量云服务器、用途：游戏网站等《腾讯云》特点：特价机便宜适合初学者用点我优惠购买

🚀 拓展型：买域名、轻量云服务器、用途：游戏网站等《阿里云》特点：中档服务器便宜域名备案事多点我优惠购买

🛡️ 稳定型：买域名、轻量云服务器、用途：游戏网站等《西部数码》特点：比上两家略贵但是稳定性超好事也少点我优惠购买

目录1、有缓冲的chan 与无缓冲的chan2、有缓冲的chan3、利用chan 实现生产者消费者4、利用chan 实现同步5、并发处理

怎么理解这个缓冲，我个人的理解是是执行这个chan 操作的时候是否发送阻塞。

操作：读和写。

读取的时候，我们都应该要是阻塞的，例如我们的socket、的recv函数。当然取决于你设置的是阻塞的套接字还是非阻塞的套接字了。

无缓冲的chan，讲究读写对称，也就是你在读的时候会阻塞，看下面这个例子：ch是一个无缓冲的chan,在主线程里面，ch<-发送了阻塞。所以后面没法执行了。

func TestChan1(t *testing.T) {
ch :=make(chan int)
<-ch
ch<-1
}

我们对此进行修改,同样的也是无缓冲的chan,只不过让读操作异步，也就是不是阻塞在主线程了，让主线程可以继续执行。

func TestChan1(t *testing.T) {
ch :=make(chan int)
go func() {
val :=<-ch
fmt.Println(val)
}()
ch<-1
time.Sleep(1*time.Second)
}

以上是无缓冲chan 的读操作，假设我们是先写呢？我们应该可以猜想到，写可能发生阻塞也可能不发生阻塞。那么无缓冲的chan 到底会不会阻塞呢？我们看下面的例子

func TestChan1(t *testing.T) {
ch :=make(chan int)
ch <- 1
<-ch
}

运行之后，发生了死锁。

对此我们可以得出的初步结论是：无缓冲的chan 读写都是阻塞的。

同理我们对此进行修改

func TestChan1(t *testing.T) {
ch :=make(chan int)
go func() {
ch <- 1
}()
val :=<-ch
fmt.Println(val)
}

无缓冲的chan的介绍，到以上就结束，我们看一下有缓冲的chan。

猜想一下有缓冲的chan 是什么存在缓冲，也就是说是读写操作哪个是非阻塞的，还是都是非阻塞的。我们看下面的例子。

第一个例子

func TestChan1(t *testing.T) {
ch :=make(chan int,1)
ch <- 1
val :=<-ch
fmt.Println(val)
}

先写入ch 然后读取。运行

这里我们得到结论：写是非阻塞。

第2 个例子：

func TestChan1(t *testing.T) {
ch :=make(chan int,1)
<-ch
ch <- 1
}

很显然我们可以猜到，会死锁。运行

对此我们对于有缓冲的chan得出的结论：读取是阻塞的。

同理，针对上面的修改：

func TestChan1(t *testing.T) {
ch :=make(chan int,1)
go func() {
val :=<-ch
fmt.Println(val)
}()
ch <- 1
time.Sleep(1 *time.Second)
}

对此我们对于chan有了一个基本的认识与使用。接下来看一下chan 几个应用实例。

生产者与消费者，说白了就是一个线程负责产生数据，另外一端消费数据。对应于我们的读写操作上来，生产者写数据，消费者读数据。对于该模型是不是，很容易利用chan来实现呢？假设我们现在是1个生产者，1个消费者，那么我们应该利用几个chan呢，很显然是一个chan 就够了，因为写入需要阻塞，那么我们的produce 是需要一个线程的，对于消费者，我们也需要一个线程，具体实现：

func TestChan1(t *testing.T) {
ch :=make(chan int,1)
defer close(ch)
go func() {
for i :=0;i<10;i++ {
ch<-i
fmt.Println(“send:”,i)
}
}()
go func() {
for {
select {
case val, ok :=<-ch:
if ok {
fmt.Println(“recv:”, val)
} else {
return
}
}
}
}()

time.Sleep(1 *time.Second)
}

针对接收数据，我们通常采用以下这种模式。

for {
select {
case <- ch:
case <-ctx.Down:
….
}
}

两条线程交替打印，例如：1-100，两条线程交替打印。

分析一下这个操作，时间上我们利用的是chan的读取阻塞的特性，实际上就是利用chan 实现同步。

func TestChan1(t *testing.T) {
ch1 :=make(chan int)
ch2 :=make(chan int)
go func() {
for i :=0; i < 50; i++ {
<-ch1
fmt.Println(2*i + 1)
ch2 <- 1
}
}()
go func() {
for i :=0; i < 50; i++ {
<-ch2
fmt.Println(2*i + 2)
ch1 <- 1
}
}()
ch1 <- 1
time.Sleep(1 * time.Second)
}

假设我们有一个任务，这个任务可以分成很多份，每个任务处理的都是相同的内容，例如多线程查询，汇总。多线程上传。具体的chan 模板代码：

// eg1: 假设10条线程处理，采用10个chan的方式
var res=0
func TestChan() {
ch :=make(chan int,1)
closeCh :=make(chan int,1)
defer close(ch)
for i :=1;i<=10;i++ {
item :=i
go func() {
ch <- item
}()
}
go func() {
for i :=0;i<10;i++{
c :=<- ch
res +=c
//fmt.Println(val)
}
closeCh<-1
}()
<-closeCh
fmt.Println(res)
}

运行结果

使用waitgroup

func WgTest() {
ch :=make(chan int, 1)
closeCh :=make(chan int,1)
wg :=sync.WaitGroup{}
wg.Add(2)
go Produce(ch,&wg)
go Produce(ch,&wg)
go Merge(ch,closeCh)
wg.Wait()
close(ch)
<-closeCh
fmt.Println(result)
return
}
func Produce(ch chan int, wg *sync.WaitGroup) {
defer func() {
wg.Done()
}()
for i :=0; i < 10; i++ {
ch <- i
}
return
}
var result=0
func Merge(ch,closeCh chan int) {
for {
select {
case val,ok :=<-ch:
if ok {
result +=val
}else {
closeCh<-1
return
}
}
}
}

到此这篇关于go chan基本使用详解的文章就介绍到这了,更多相关go chan使用内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:golang中for循环遍历channel时需要注意的问题详解golang判断chan channel是否关闭的方法Go语言的管道Channel用法实例详解Golang中Channel的用法golang实现基于channel的通用连接池详解