Go语言通道之缓冲通道

前文为大家讲解了Go语言通道之无缓冲通道

有缓冲的通道相比于无缓冲通道，多了一个缓存的功能，如下图描述的一样：

从图上可以明显看到和无缓冲通道的区别，无缓冲必须两个Goroutine都进入通道才能进行数据的交换，这个不用，如果数据有，直接就能拿走。

package ChannelDemo

import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)

const (
    numberGoroutines = 4
    taskLoad         = 10
)

var bufferWg sync.WaitGroup

func init() {
    rand.Seed(time.Now().Unix())
}

func main() {
    //创建了一个10任务的缓冲通道
    tasks := make(chan string, taskLoad)
    bufferWg.Add(numberGoroutines)

    //创建4个Goroutine
    for gr := 1; gr <= numberGoroutines; gr++ {
        go worker(tasks, gr)
    }

    //向缓冲通道中放入数据
    for post := 1; post <= taskLoad; post++ {
        tasks <- fmt.Sprintf("Task : %d", post)
    }

    close(tasks)

    bufferWg.Wait()
}

func worker(tasks chan string, worker int) {
    defer bufferWg.Done()

    for {
        task, ok := <-tasks
        if !ok {
            fmt.Printf("Worker: %d : 结束工作 \n", worker)
            return
        }

        fmt.Printf("Worker: %d : 开始工作 %s\n", worker, task)

        //随机处理一下工作的时间
        sleep := rand.Int63n(100)
        time.Sleep(time.Duration(sleep) * time.Millisecond)

        fmt.Printf("Worker: %d : 完成工作 %s\n", worker, task)
    }
}

运行结果：

Worker: 3 : 开始工作 Task : 4
Worker: 2 : 开始工作 Task : 2
Worker: 1 : 开始工作 Task : 1
Worker: 4 : 开始工作 Task : 3
Worker: 4 : 完成工作 Task : 3
Worker: 4 : 开始工作 Task : 5
Worker: 2 : 完成工作 Task : 2
Worker: 2 : 开始工作 Task : 6
Worker: 3 : 完成工作 Task : 4
Worker: 3 : 开始工作 Task : 7
Worker: 1 : 完成工作 Task : 1
Worker: 1 : 开始工作 Task : 8
Worker: 3 : 完成工作 Task : 7
Worker: 3 : 开始工作 Task : 9
Worker: 1 : 完成工作 Task : 8
Worker: 1 : 开始工作 Task : 10
Worker: 4 : 完成工作 Task : 5
Worker: 4 : 结束工作
Worker: 3 : 完成工作 Task : 9
Worker: 3 : 结束工作
Worker: 2 : 完成工作 Task : 6
Worker: 2 : 结束工作
Worker: 1 : 完成工作 Task : 10
Worker: 1 : 结束工作

因为哪一个worker先从通道中取值有系统自己进行调度的，所以每次运行的结果稍微不同，但是相同的是10个任务被4个协程有条不紊的完成了

注意：main中有一句代码 Close(tasks) 关闭通道的代码非常重要。当通道关闭后，goroutine 依旧可以从通道接收数据，但是不能再向通道里发送数据。

能够从已经关闭的通道接收数据这一点非常重要，因为这允许通道关闭后依旧能取出其中缓冲的全部值，而不会有数据丢失.

总结

无缓冲的通道保证同时交换数据，而有缓冲的通道不做这种保证。

到此这篇关于Go语言通道之缓冲通道的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持我们。

赞 (0)

相关推荐

  • Go通道channel通过通信共享内存

    目录 引言 通道的声明与创建 接收 & 发送数据 引言 不要通过共享内存来通信 应该通过通信来共享内存 这句话有网友的解释如下: 这句俏皮话具体说来就是,不同的线程不共享内存不用锁,线程之间通讯用通道(channel)同步也用channel. chanel是协程之间传递信息的媒介,优雅地解决了某些后端开发常用语言中随处可见的lock,unlock,临界区等,把从很多线程层面解决的问题移到协程,从而静态地保证没有数据竞争. 通道的声明与创建 伪代码如下: //声明类型 var 通道名 chan 数

  • Golang通道的无阻塞读写的方法示例

    无论是无缓冲通道,还是有缓冲通道,都存在阻塞的情况,但其实有些情况,我们并不想读数据或者写数据阻塞在那里,有1个唯一的解决办法,那就是使用select结构. 这篇文章会介绍,哪些情况会存在阻塞,以及如何使用select解决阻塞. 阻塞场景 阻塞场景共4个,有缓存和无缓冲各2个. 无缓冲通道的特点是,发送的数据需要被读取后,发送才会完成,它阻塞场景: 通道中无数据,但执行读通道. 通道中无数据,向通道写数据,但无协程读取. // 场景1 func ReadNoDataFromNoBufCh() {

  • Go语言七篇入门教程四通道及Goroutine

    Go语言七篇入门教程四通道及Goroutine

    目录 1. 前言 2. 通道简介 2.1 声明 2.1 读写 2.3 通道详解 2.3.1 例子 2.3.2 死锁 2.3.3 关闭通道 2.3.4 缓冲区 2.3.5 通道的长度和容量 2.3.6 单向通道 2.3.7 Select 2.3.8 default case 块 2.3.9 空 select 2.3.10 Deadlock 2.3.11 nil通道 2.4 多协程协同工作 2.5 WaitGroup 2.5.1 简介 2.5.2工作池 2.5.3 Mutex 3. 结语 如何学习G

  • Go语言带缓冲的通道实现

    Go语言中有缓冲的通道(buffered channel)是一种在被接收前能存储一个或者多个值的通道.这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收.通道会阻塞发送和接收动作的条件也会不同.只有在通道中没有要接收的值时,接收动作才会阻塞.只有在通道没有可用缓冲区容纳被发送的值时,发送动作才会阻塞. 这导致有缓冲的通道和无缓冲的通道之间的一个很大的不同:无缓冲的通道保证进行发送和接收的 goroutine 会在同一时间进行数据交换:有缓冲的通道没有这种保证. 在无缓冲通

  • Golang 并发以及通道的使用方式

    Golang最擅长的就是并发编程,使用Golang可以很方便的进行并发编程.先看一段普通的代码 package main import ( "fmt" "time" ) func Foo(i int) { fmt.Printf("%d will sleep\n", i) time.Sleep(5 * time.Second) fmt.Printf("%d wake up\n", i) } func main() { for i

  • Go语言通道之无缓冲通道

    Go语言通道之无缓冲通道

    一.通道是什么? 其实无论是原子函数还是共享锁都是通过共享内存的方式进行的同步.效率一般不高,而Go语言中则使用了通道,它是一种通过传递信息的方式进行数据同步,通过发送和接收需要共享的资源,在goroutine 之间做同步.可以把通道看作是Goroutine之间的桥梁. 例1:创建一个通道 // 无缓冲的整型通道 unbuffered := make(chan int) // 有缓冲的字符串通道 buffered := make(chan string, 10) 通道分为有缓冲和无缓冲的通道.

  • golang redis中Pipeline通道的使用详解

    目录 一.pipeline出现的背景 二.pipeline的用法 pipeline命令的使用 goredis库连接客户端 package client import (     "github.com/go-redis/redis"     "github.com/sirupsen/logrus" ) var MainRDS *redis.Client func init() {     ConnectRedis() } func ConnectRedis() {

  • Go语言中的通道channel详情

    目录 一.Go语言通道基础概念 1.channel产生背景 2.channel工作方式 二.通道使用语法 1.通道的声明与初始化 2.将数据放入通道内 3.从通道内取出数据 4.关闭通道close 三.单项通道及通道的状态分析 1.单项输出通道 2.单项输入通道 3.通道的状态 四.通道死锁原因分析 一.Go语言通道基础概念 1.channel产生背景 线程之间进行通信的时候,会因为资源的争夺而产生竟态问题,为了保证数据交换的正确性,必须使用互斥量给内存进行加锁,go语言并发的模型是CSP,提倡

  • Golang实现Directional Channel(定向通道)

    Golang实现Directional Channel(定向通道)

    通道可以是定向的( directional ).在默认情况下,通道将以双向的( bidirectional )形式运作,用户既可以把值放人通道,也可以从通道取出值;但是,通道也可以被限制为只能执行发送操作( send-only )或者只能执行接收操作( receive-only ). 通常可以叫 定向通道 ,也有人叫 单向通道 ,两者其实都是指向这篇短文要讨论的 Directional Channel . 下面直接举例子说明: package onlyChannelTest import ( "

  • Go语言通道之缓冲通道

    Go语言通道之缓冲通道

    前文为大家讲解了Go语言通道之无缓冲通道 有缓冲的通道相比于无缓冲通道,多了一个缓存的功能,如下图描述的一样: 从图上可以明显看到和无缓冲通道的区别,无缓冲必须两个Goroutine都进入通道才能进行数据的交换,这个不用,如果数据有,直接就能拿走. package ChannelDemo import ( "fmt" "math/rand" "sync" "time" ) const ( numberGoroutines =

  • Go语言使用goroutine及通道实现并发详解

    Go语言使用goroutine及通道实现并发详解

    目录 使用通道接收数据 阻塞接收数据 非阻塞接收数据 接收任意数据,忽略掉接收的数据 循环接收数据 使用通道接收数据 在上一篇文章中介绍了通道以及使用通道发送数据,本篇接着了解通道的基本内容,如何使用通道接收数据: 通道的接收同样使用"<-"操作符: 使用通道接收数据的特性如下: 通道的发送和接收操作在不同的两个goroutine间进行,由于通道中的数据在没有接收方接收时会持续阻塞,所以通道的接收必定在另外一个goroutine中进行: 如果在接收方接收时,通道中没有发送方发送数

  • python 实现单通道转3通道

    下面有两种方法都可以: import numpy as np a=np.asarray([[10,20],[101,201]]) # a=a[:,:,np.newaxis] # print(a.shape) # b= a.repeat([3],axis=2) # print(b.shape,b) image = np.expand_dims(a, axis=2) image = np.concatenate((image, image, image), axis=-1) print(image)

  • GO语言中通道和sync包的使用教程分享

    目录 GO通道和 sync 包的分享 通道是什么 通道能做什么 通道有哪几种 无缓冲通道 有缓冲的通道 单向通道 如何创建和声明一个通道 声明通道 初始化通道 如何操作 channel 通道异常情况梳理 每一种通道的DEMO实战 无缓冲通道 有缓冲通道 单向通道 关闭通道 总结 GO通道和 sync 包的分享 我们一起回顾一下上次分享的内容: GO协程同步若不做限制的话,会产生数据竞态的问题 我们用锁的方式来解决如上问题,根据使用场景选择使用互斥锁 和 读写锁 比使用锁更好的方式是原子操作,但是

  • Go中Channel发送和接收操作指南

    目录 前言 一.Channel的定义 二.Channel的操作 三.Channel发送和接收操作的特点 四.Channel的类型 五.Channel的源码学习 总结 前言 先来看一道面试题: 对已经关闭的 chan 进行读写,会怎么样?为什么? 在上一篇学习 Go 协程的文章中,知道 go 关键字可以用来开启一个 goroutine 进行任务处理,但多个任务之间如果需要通信,就需要用到通道(channel)了. 一.Channel的定义 声明并初始化一个通道,可以使用 Go 语言的内建函数 ma

  • Go语言入门学习之Channel通道详解

    目录 前言 通道的声明 通道的初始化 发送和接收数据 通道的关闭 通道的容量与长度 缓冲通道与无缓冲通道 双向通道和单向通道 遍历通道 fibonacci 数列 参考文章: 总结 前言 不同于传统的多线程并发模型使用共享内存来实现线程间通信的方式,go 是通过 channel 进行协程 (goroutine) 之间的通信来实现数据共享. channel,就是一个管道,可以想像成 Go 协程之间通信的管道.它是一种队列式的数据结构,遵循先入先出的规则. 通道的声明 每个通道都只能传递一种数据类型的

随机推荐