标签：lang 协程 int fmt ch1 Go main 通道

众所周知，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的多核资源。

标签：lang,协程,int,fmt,ch1,Go,main,通道
来源： https://www.cnblogs.com/v3ucn/p/16640477.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。