channel管道

目录

定义channel管道

定义一个channel时，也需要定义发送到管道的值类型。channel可以使用内置的make()函数来创建：

var ch = make(chan int) //等价于：make(chan Type,0)
var ch = make(chan Type,capacity)
当capacity=0时，channel管道是无缓冲阻塞读写，
当capacity>0时，channel管道有缓冲，是非阻塞的，直到写满capacity个元素才阻塞写入。

channel管道塞值和取值

ch <- 666  //向ch管道塞入666
<- ch  // 向ch管道接收值，并丢弃
x := <-ch  //向ch管道中接收数据，并复制给x
x, ok := <-ch  //向ch管道中接收数据，并复制给x,同时检查通道是否已关闭或者是否为空

注意：默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得goroutine同步变得更加简单，而不需要显示的lock。

通过channel管道实现同步，和数据交互

package main

import (
	"fmt"
	"time"
)

func main() {

	//创建channel
	ch := make(chan string)

	defer fmt.Println("主协程也结束")

	go func() {
		defer fmt.Println("子协程调用完毕")

		for i := 0; i < 2; i++ {
			fmt.Println("子协程 i = ", i)
			time.Sleep(time.Second)
		}

		ch <- "我是子协程，要工作完毕"

	}()

	str := <-ch //没有数据前，阻塞
	fmt.Println("str = ", str)
}

无缓冲的channel

ch := make(chan int, 0)

package main

import (
	"fmt"
	"time"
)

func main() {
	//创建一个无缓存的channel
	ch := make(chan int, 0)

	//len(ch)缓冲区剩余数据个数， cap(ch)缓冲区大小
	fmt.Printf("len(ch) = %d, cap(ch)= %d\n", len(ch), cap(ch))

	//新建协程
	go func() {
		for i := 0; i < 10000; i++ {
			fmt.Printf("子协程：i = %d\n", i)
			ch <- i //往chan写内容
			time.Sleep(1 * time.Second)
		}
	}()

	go func() {
		for  {
			num := <-ch //读管道中内容，没有内容前，阻塞
			fmt.Println("num = ", num)
		}

	}()
	for {
	
	}
}

有缓冲的channel管道

ch := make(chan int, 3)

package main

import (
	"fmt"
	"time"
)

func main() {
	//创建一个有缓存的channel
	ch := make(chan int, 3)

	//len(ch)缓冲区剩余数据个数， cap(ch)缓冲区大小
	fmt.Printf("len(ch) = %d, cap(ch)= %d\n", len(ch), cap(ch))

	//新建协程
	go func() {
		for i := 0; i < 10; i++ {
			ch <- i //往chan写内容
			fmt.Printf("子协程[%d]: len(ch) = %d, cap(ch)= %d\n", i, len(ch), cap(ch))
		}
	}()

	//延时
	time.Sleep(2 * time.Second)

	for i := 0; i < 10; i++ {
		num := <-ch //读管道中内容，没有内容前，阻塞
		fmt.Println("num = ", num)
	}

}

关闭channel管道

close(ch)

package main

import (
	"fmt"
)

func main() {
	//创建一个无缓存的channel
	ch := make(chan int, 3)

	//len(ch)缓冲区剩余数据个数， cap(ch)缓冲区大小
	fmt.Printf("len(ch) = %d, cap(ch)= %d\n", len(ch), cap(ch))

	//新建协程
	go func() {
		for i := 0; i < 10000; i++ {
			fmt.Printf("子协程：i = %d\n", i)
			ch <- i //往chan写内容
			//time.Sleep(1 * time.Second)
			if i >10 {
				close(ch)
				break
			}

		}
	}()

	go func() {
		for  {
			if num, ok := <-ch; ok == true {
				fmt.Println("num = ", num)
			} else { //管道关闭
				break
			}
		}

	}()
	for {

	}
}

单向channel管道,读写分离

chan<-  表示数据进入管道，只写
<-chan 表示数据从管道出来，只读

注意：双向可转为单向，单向不可转为双向

package main

//"fmt"

func main() {
	//创建一个channel, 双向的
	ch := make(chan int)

	//双向channel能隐式转换为单向channel
	var writeCh chan<- int = ch //只能写，不能读
	var readCh <-chan int = ch  //只能读，不能写

	writeCh <- 666 //写
	//<-writeCh //err,  invalid operation: <-writeCh (receive from send-only type chan<- int)

	<-readCh //读
	//readCh <- 666 //写， err,  invalid operation: readCh <- 666 (send to receive-only type <-chan int)

	//单向无法转换为双向
	//var ch2 chan int = writeCh //cannot use writeCh (type chan<- int) as type chan int in assignment

}

管道消费者生产者模型

package main

import (
	"fmt"
)

//此通道只能写，不能读
func producer(out chan<- int) {
	for i := 0; i < 10; i++ {
		out <- i * i  //写入
	}
	close(out)  //关闭
}

//此channel只能读，不能写
func consumer(data <-chan int) {
	for num := range data {
		fmt.Println("num = ", num)
	}
}

func main() {
	//创建一个双向通道
	ch := make(chan int)

	//生产者，生产数字，写入channel
	//新开一个协程
	go producer(ch) //channel传参，引用传递

	//消费者，从channel读取内容，打印
	consumer(ch)
}
posted @ 2020-11-16 18:03  Jeff的技术栈  阅读(142)  评论(0)  编辑  收藏  举报
回顶部