Go语言中的通道-channel

为什么80%的码农都做不了架构师？>>>   

主要讲解Go语言中的通道-channel

1、通道（channel）的概念

        通道（channel）是 goroutine 与 goroutine 之间用于传递数据的通道，使用通道的意义在于：

不要通过共享内存来通信，而是通过通信来共享内存

 

2、Go语言中 channel 代码示例

        主要知识点：

• 定义一个chanel：c := make(chan int)
• 只收数据的chanel ：chan<-
• 只发数据的chanel：<-chan
• chanel 缓冲区及其意义
• 使用range判断chanel是否已经关闭

package main

import (
	"fmt"
	"time"
)
//传入一个 数字标志 和 一个 channel
// 主要用于消费channel里面的数据

func worker(id int, c chan int) {
	//不断从channel 中取出数据 
	// 使用range判断chanel里面的数据是否已经发送完成
	// 当消息发送方 调用 close 方法，则说明chanel 已经发送完成
	for n := range c {
		fmt.Printf("Worker %d received %c\n",id, n)
	}
}

// 构建一个 channel 创建者
// chan<- int 代表一个接收 int 类型的通道，
// 外部 通过 调用此方法获取到的 channel只能进行写入操作
func createWorker(id int) chan<- int {
	//定义一个传递int类型数据的  chanle
	c := make(chan int)
	//使用协程消费channel
	go worker(id, c)
	//返回channel，外部获取到channel之后，写入数据
	return c
}

func chanDemo() {
	//创建10个 channel
	var channels [10]chan<- int
	for i := 0; i < 10; i++ {
		channels[i] = createWorker(i)
	}
	//往channel 中写入数据
	for i := 0; i < 10; i++ {
		channels[i] <- 'a' + i
	}
	//往channel 中写入数据
	for i := 0; i < 10; i++ {
		channels[i] <- 'A' + i
	}

	time.Sleep(time.Millisecond)
}
//构建一个带缓冲区的channel
func bufferedChannel() {

	// 缓冲区大小默认为1，当通道缓冲区被存满数据后，协程调度器会切换至通道消费 协程
	// 缓冲区为1 代表 每写入一个数据 就要切换一次 协程，
	// 使用缓冲区可以提高部分性能
	c := make(chan int, 3) //缓冲区大小为 3
	go worker(0, c)
	c <- 'a'
	c <- 'b'
	c <- 'c' // 运行至此处报错，因为缓冲区满，切换协程
	c <- 'd'
	time.Sleep(time.Millisecond)
}

// 通过close 可以关闭通道
func channelClose() {
	c := make(chan int)
	go worker(0, c)
	c <- 'a'
	c <- 'b'
	c <- 'c'
	c <- 'd'
	close(c)
	time.Sleep(time.Millisecond)
}

func main() {
	fmt.Println("Channel as first-class citizen")
	chanDemo()
	fmt.Println("Buffered channel")
	bufferedChannel()
	fmt.Println("Channel close and range")
	channelClose()

}

3、使用 WaitGroup 等待 协程执行完成

        通过channel 可以在不同的协程之间发送信息，如何判断所有的协程都已经执行完毕，此处可以使用WaitGroup ，它能够一直等到所有的goroutine执行完成，并且阻塞主线程的执行，直到所有的goroutine执行完成。

        以下为代码示例：

package main

import (
	"fmt"
	"sync"
)

func doWork(id int,
	w worker) {
	for n := range w.in {
		fmt.Printf("Worker %d received %c\n",
			id, n)
		w.done()
	}
}

type worker struct {
	in   chan int
	done func()
}

func createWorker(id int, wg *sync.WaitGroup) worker {
	w := worker{
		in: make(chan int),
		done: func() {
			wg.Done()
		},
	}
	go doWork(id, w)
	return w
}

func chanDemo() {
	var wg sync.WaitGroup

	var workers [10]worker
	for i := 0; i < 10; i++ {
		workers[i] = createWorker(i, &wg)
	}

	//使用 WaitGroup 可以等待 goroutine指定完成
	wg.Add(20) //此处设置20次执行，

	for i, worker := range workers {
		worker.in <- 'a' + i
	}
	for i, worker := range workers {
		worker.in <- 'A' + i
	}

	// 在收到20次 Done 之后 才不会阻塞
	wg.Wait()
}

func main() {
	chanDemo()
}

 

转载于:https://my.oschina.net/ruoli/blog/1816724