大道如青天,协程来通信,Go lang1.18入门精炼教程,由白丁入鸿儒,Go lang通道channel的使用EP14

简介: 众所周知,Go lang的作用域相对严格,数据之间的通信往往要依靠参数的传递,但如果想在多个协程任务中间做数据通信,就需要通道(channel)的参与,我们可以把数据封装成一个对象,然后把这个对象的指针传入某个通道变量中,另外一个协程从这个通道中读出变量的指针,并处理其指向的内存对象。

众所周知,Go lang的作用域相对严格,数据之间的通信往往要依靠参数的传递,但如果想在多个协程任务中间做数据通信,就需要通道(channel)的参与,我们可以把数据封装成一个对象,然后把这个对象的指针传入某个通道变量中,另外一个协程从这个通道中读出变量的指针,并处理其指向的内存对象。

通道的声明与创建

  

package main  
  
import "fmt"  
  
func main() {  
    var a chan int  
    if a == nil {  
        fmt.Println("通道是空的, 不能使用,需要先创建通道")  
        a = make(chan int)  
        fmt.Printf("数据类型是: %T", a)  
    }  
}

这里注意,通道声明之后还需要进行创建。

也可以通过海象操作符声明并创建:

package main  
  
import "fmt"  
  
func main() {  
      
    a := make(chan int)  
  
    fmt.Printf("数据类型是: %T", a)  
  
}

程序返回:

数据类型是: chan int%

如此,一个类型为整形的通道就创建好了。

此外,通道是引用数据类型:

package main  
  
import (  
    "fmt"  
)  
  
func main() {  
    ch1 := make(chan int)  
    fmt.Printf("%T,%p\n", ch1, ch1)  
  
    test1(ch1)  
  
}  
  
func test1(ch chan int) {  
    fmt.Printf("%T,%p\n", ch, ch)  
}

程序返回:

chan int,0x1400010e060  
chan int,0x1400010e060

可以看到,在test1函数内和main函数内通道的地址是一样的,所以他们指向的都是同一个通道。

通道的使用

通道创建之后,即可以在协程之间充当桥梁:

package main  
  
import "fmt"  
  
func job(ch1 chan int) {  
  
    ch1 <- 1  
  
}  
  
func main() {  
  
    ch1 := make(chan int)  
  
    fmt.Println(ch1)  
  
    go job(ch1)  
  
    data := <-ch1 // 从ch1通道中读取数据  
    fmt.Println("data-->", data)  
    fmt.Println("main。。over。。。。")  
}

这里我们声明一个函数job,把通道作为参数传递进去,注意这里参数类型除了声明通道本身以外,还得声明通道具体的数据类型。

随后在main函数中,可以理解为主协程,创建通道ch1,执行开启协程任务job,在job函数内,往通道内传递数字1

接着,主协程获取通道内由job协程传递的数据:

0x1400006a060  
data--> 1  
main。。over。。。。

藉此,就完成了数据的传递。

这里需要注意通道的调用语法:

data := <- a // 读取通道  
a <- data // 写入通道

同步阻塞

这里需要注意的是,通道无论是写入还是读取,都是同步阻塞机制。即当有协程对通道进行操作的时候,其他协程都处于“等待”状态,说白了,就是在“排队”,在之前的一篇:并发与并行,同步和异步,Go lang1.18入门精炼教程,由白丁入鸿儒,Go lang并发编程之GoroutineEP13,我们要么通过sync.WaitGroup来阻塞主协程,或者通过time.Sleep(time.Second)方法来阻塞,就是怕主协程提前执行完,早成子协程来不及执行。

而通道的出现,就间接帮我们实现了“阻塞”主协程的目的。

比如,多个协程任务操作一个变量:

package main  
  
import (  
    "fmt"  
)  
  
func job1(number int, squareop chan int) {  
    sum := 20  
    sum += number  
    squareop <- sum  
}  
  
func job2(number int, cubeop chan int) {  
    sum := 10  
    sum += number  
    cubeop <- sum  
}  
func main() {  
    number := 0  
    ch1 := make(chan int)  
    ch2 := make(chan int)  
    go job1(number, ch1)  
    go job2(number, ch2)  
    num1, num2 := <-ch1, <-ch2  
    fmt.Println("Final output", num1+num2)  
}

这里job1和job2两个协程任务同时异步执行,操作number变量,累加后往通道中写入,程序返回:

Final output 30

理论上,如果是并发执行,返回值应该是20或者10,但由于通道的存在,造成协程任务阻塞,变回了同步执行,所以返回了30。

同时,我们需要注意死锁问题,如果一个协程任务在一个通道上发送数据,那么其他的协程任务应该接收数据,如果这种情况不发生,那么程序将在运行时出现死锁。

换句话说,你发送了,就得有人接收,只发不接,或者只收不发,都会变成死锁。

此外,协程任务可以通过close(ch)方法来关闭通道:

package main  
  
import (  
    "fmt"  
)  
  
func job(ch1 chan int) {  
    // 发送方:3条数据  
    for i := 0; i < 3; i++ {  
        ch1 <- i //将i写入通道中  
    }  
    close(ch1) //将ch1通道关闭了。  
}  
  
func main() {  
    ch1 := make(chan int)  
    go job(ch1)  
    /*  
        子goroutine,写出数据3个  
                每写一个,阻塞一次,主程序读取一次,解除阻塞  
  
        主goroutine:循环读  
                每次读取一个,堵塞一次,子程序,写出一个,解除阻塞  
  
        发送发,关闭通道的--->接收方,接收到的数据是该类型的零值,以及false  
    */  
    //主程序中获取通道的数据  
    for {  
  
        v, ok := <-ch1 //其他goroutine,显示的调用close方法关闭通道。  
        if !ok {  
            fmt.Println("已经读取了所有的数据,", ok)  
            break  
        }  
        fmt.Println("取出数据:", v, ok)  
    }  
  
    fmt.Println("main...over....")  
}

这里将0到2写入chl通道,然后关闭通道。主函数里有一个死循环。类似while,它轮询通道是否在发送数据后,使用变量ok进行判断。如果ok是假的,则意味着通道关闭,因此循环结束,否则将会继续进行无限轮询。

select关键字

select 是 Go lang里面的一个流程控制结构,和switch关键字差不多,但是select会随机执行一个可运行的通道通信,如果没有通道通信可运行,它将阻塞,直到有通道通信可运行:

package main  
  
import (  
    "fmt"  
    "time"  
)  
  
func job(ch1 chan int) {  
  
    time.Sleep(2 * time.Second)  
    ch1 <- 200  
  
}  
  
func main() {  
  
    ch1 := make(chan int)  
    ch2 := make(chan int)  
  
    go job(ch1)  
    go job(ch2)  
  
    select {  
    case num1 := <-ch1:  
        fmt.Println("ch1中取数据。。", num1)  
    case num2, ok := <-ch2:  
        if ok {  
            fmt.Println("ch2中取数据。。", num2)  
        } else {  
            fmt.Println("ch2通道已经关闭。。")  
        }  
  
    }  
}

这里select会随机选择一个可运行的通道通信逻辑,可能是ch1通道,也有可能是ch2通道:

➜  mydemo git:(master) ✗ go run "/Users/liuyue/wodfan/work/mydemo/hello.go"  
ch1中取数据。。 200  
➜  mydemo git:(master) ✗ go run "/Users/liuyue/wodfan/work/mydemo/hello.go"  
ch1中取数据。。 200  
➜  mydemo git:(master) ✗ go run "/Users/liuyue/wodfan/work/mydemo/hello.go"  
ch2中取数据。。 200  
➜  mydemo git:(master) ✗

结语

综上,Golang的通道其实就是将协程任务进行隔离,编写并发逻辑时,关注通道即可,说白了,Golang的通道就是Python多进程通信中的管道,Golang虽然没有显性的多进程调用,但其协程调度底层就是多进程之间的通信,因为只有多进程才可能利用CPU的多核资源。

相关文章
|
8天前
|
安全 Go 调度
探索Go语言的并发模式:协程与通道的协同作用
Go语言以其并发能力闻名于世,而协程(goroutine)和通道(channel)是实现并发的两大利器。本文将深入了解Go语言中协程的轻量级特性,探讨如何利用通道进行协程间的安全通信,并通过实际案例演示如何将这两者结合起来,构建高效且可靠的并发系统。
|
9天前
|
安全 Go 调度
探索Go语言的并发之美:goroutine与channel
在这个快节奏的技术时代,Go语言以其简洁的语法和强大的并发能力脱颖而出。本文将带你深入Go语言的并发机制,探索goroutine的轻量级特性和channel的同步通信能力,让你在高并发场景下也能游刃有余。
|
12天前
|
存储 安全 Go
探索Go语言的并发模型:Goroutine与Channel
在Go语言的多核处理器时代,传统并发模型已无法满足高效、低延迟的需求。本文深入探讨Go语言的并发处理机制,包括Goroutine的轻量级线程模型和Channel的通信机制,揭示它们如何共同构建出高效、简洁的并发程序。
|
4天前
|
存储 Go 调度
深入理解Go语言的并发模型:goroutine与channel
在这个快速变化的技术世界中,Go语言以其简洁的并发模型脱颖而出。本文将带你穿越Go语言的并发世界,探索goroutine的轻量级特性和channel的同步机制。摘要部分,我们将用一段对话来揭示Go并发模型的魔力,而不是传统的介绍性文字。
|
10天前
|
安全 Go 调度
探索Go语言的并发模型:Goroutine与Channel的魔力
本文深入探讨了Go语言的并发模型,不仅解释了Goroutine的概念和特性,还详细讲解了Channel的用法和它们在并发编程中的重要性。通过实际代码示例,揭示了Go语言如何通过轻量级线程和通信机制来实现高效的并发处理。
|
18天前
|
安全 Go 调度
探索Go语言的并发之美:goroutine与channel的实践指南
在本文中,我们将深入探讨Go语言的并发机制,特别是goroutine和channel的使用。通过实际的代码示例,我们将展示如何利用这些工具来构建高效、可扩展的并发程序。我们将讨论goroutine的轻量级特性,channel的同步通信能力,以及它们如何共同简化并发编程的复杂性。
|
20天前
|
安全 Go 数据处理
掌握Go语言并发:从goroutine到channel
在Go语言的世界中,goroutine和channel是构建高效并发程序的基石。本文将带你一探Go语言并发机制的奥秘,从基础的goroutine创建到channel的同步通信,让你在并发编程的道路上更进一步。
|
2月前
|
Go
golang语言之go常用命令
这篇文章列出了常用的Go语言命令,如`go run`、`go install`、`go build`、`go help`、`go get`、`go mod`、`go test`、`go tool`、`go vet`、`go fmt`、`go doc`、`go version`和`go env`,以及它们的基本用法和功能。
41 6
|
2月前
|
存储 Go
Golang语言基于go module方式管理包(package)
这篇文章详细介绍了Golang语言中基于go module方式管理包(package)的方法,包括Go Modules的发展历史、go module的介绍、常用命令和操作步骤,并通过代码示例展示了如何初始化项目、引入第三方包、组织代码结构以及运行测试。
41 3
|
3月前
|
Go 开发者
深入理解Go语言的通道:概念与使用
【8月更文挑战第31天】
40 0