Go语言精修（尚硅谷笔记）第十七和十八章

Posted 2023-04-03 瞧帆

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Go语言精修（尚硅谷笔记）第十七和十八章相关的知识，希望对你有一定的参考价值。

十七、反射

17.1 基本介绍

1 ) 反射可以在运行时动态获取变量的各种信息, 比如变量的类型(type)，类别(kind)

2 ) 如果是结构体变量，还可以获取到结构体本身的信息(包括结构体的字段、方法)

3 ) 通过反射，可以修改变量的值，可以调用关联的方法。

4 ) 使用反射，需要 import(“ reflect ”)

5 ) 示意图

17.2 反射应用场景

不知道接口调用哪个函数，根据传入参数在运行时确定调用的具体接口，这种需要对函数或方法反射。例如以下这种桥接模式。

func bridge（funcPtr interface，args ...interface)

第一个参数funcPtr以接口的形式传入函数指针，函数参数args以可变参数的形式传入，bridge函数中可以用反射来动态执行funcPtr函数

对结构体序列化时，如果结构体有指定Tag，也会使用到反射生成对应的字符串。

17.3 反射重要的函数和概念

reflect.TypeOf(变量名)，获取变量的类型，返回reflext.Type类型

2）reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型reflect.Value是一个结构体类型。通过reflect.Value，可以获取到该变量的很多信息。

3 ) 变量、interface 和 reflect.Value是可以相互转换的，这点在实际开发中，会经常使用到。画出示意图

案例

package main
import (
	"reflect"
	"fmt"
)


//专门演示反射
func reflectTest01(b interface) 

	//通过反射获取的传入的变量的 type , kind, 值
	//1. 先获取到 reflect.Type
	rTyp := reflect.TypeOf(b)
	fmt.Println("rType=", rTyp)

	//2. 获取到 reflect.Value
	rVal := reflect.ValueOf(b)
	
	n2 := 2 + rVal.Int()
	//n3 := rVal.Float()
	fmt.Println("n2=", n2)
	//fmt.Println("n3=", n3)
	
	fmt.Printf("rVal=%v rVal type=%T\\n", rVal, rVal)

	//下面我们将 rVal 转成 interface
	iV := rVal.Interface()
	//将 interface 通过断言转成需要的类型
	num2 := iV.(int)
	fmt.Println("num2=", num2)




//专门演示反射[对结构体的反射]
func reflectTest02(b interface) 

	//通过反射获取的传入的变量的 type , kind, 值
	//1. 先获取到 reflect.Type
	rTyp := reflect.TypeOf(b)
	fmt.Println("rType=", rTyp)

	//2. 获取到 reflect.Value
	rVal := reflect.ValueOf(b)

	//3. 获取 变量对应的Kind
	//(1) rVal.Kind() ==> 
	kind1 := rVal.Kind()
	//(2) rTyp.Kind() ==>
	kind2 := rTyp.Kind()
	fmt.Printf("kind =%v kind=%v\\n", kind1, kind2)
	


	//下面我们将 rVal 转成 interface
	iV := rVal.Interface()
	fmt.Printf("iv=%v iv type=%T \\n", iV, iV)
	//将 interface 通过断言转成需要的类型
	//这里，我们就简单使用了一带检测的类型断言.
	//同学们可以使用 swtich 的断言形式来做的更加的灵活
	stu, ok := iV.(Student)
	if ok 
		fmt.Printf("stu.Name=%v\\n", stu.Name)
	



type Student struct 
	Name string
	Age int


type Monster struct 
	Name string
	Age int


func main() 

	//请编写一个案例，
	//演示对(基本数据类型、interface、reflect.Value)进行反射的基本操作

	//1. 先定义一个int
	var num int = 100
	reflectTest01(num)

	//2. 定义一个Student的实例
	stu := Student
		Name : "tom",
		Age : 20,
	
	reflectTest02(stu)

17.4 反射注意事项

1 ) reflect.Value.Kind，获取变量的类别，返回的是一个常量

2 ) Type 和 Kind 的区别

Type是类型,Kind是类别，Type 和 Kind 可能是相同的，也可能是不同的

比如: varnumint= 10 num的Type是int,Kind也是int

比如: varstuStudent stu的Type是 pkg 1 .Student,Kind是struct

3）通过反射可以在让变量在interface和Reflect.Value之间相互转换，这点在前面画过示意图并在快速入门案例中讲解过，这里我们看下是如何在代码中体现的。

5 ) 通过反射的来修改变量, 注意当使用SetXxx方法来设置需要通过对应的指针类型来完成, 这样才能改变传入的变量的值, 同时需要使用到reflect.Value.Elem()方法

package main
import (
	"reflect"
	"fmt"
)

//通过反射，修改,
// num int 的值
// 修改 student的值

func reflect01(b interface) 
	//2. 获取到 reflect.Value
	rVal := reflect.ValueOf(b)
	// 看看 rVal的Kind是 
	fmt.Printf("rVal kind=%v\\n", rVal.Kind())
	//3. rVal
	//Elem返回v持有的接口保管的值的Value封装，或者v持有的指针指向的值的Value封装
	rVal.Elem().SetInt(20)


func main() 

	var num int = 10
	reflect01(&num)
	fmt.Println("num=", num) // 20


	//你可以这样理解rVal.Elem()
	// num := 9
	// ptr *int = &num
	// num2 := *ptr  //=== 类似 rVal.Elem()

6 ) reflect.Value.Elem() 应该如何理解？

17.4 反射实践

1 ) 使用反射来遍历结构体的字段，调用结构体的方法，并获取结构体标签的值

package main
import (
	"fmt"
	"reflect"
)
//定义了一个Monster结构体
type Monster struct 
	Name  string `json:"name"`
	Age   int `json:"monster_age"`
	Score float32 `json:"成绩"`
	Sex   string
	


//方法，返回两个数的和
func (s Monster) GetSum(n1, n2 int) int 
	return n1 + n2

//方法， 接收四个值，给s赋值
func (s Monster) Set(name string, age int, score float32, sex string) 
	s.Name = name
	s.Age = age
	s.Score = score
	s.Sex = sex


//方法，显示s的值
func (s Monster) Print() 
	fmt.Println("---start~----")
	fmt.Println(s)
	fmt.Println("---end~----")

func TestStruct(a interface) 
	//获取reflect.Type 类型
	typ := reflect.TypeOf(a)
	//获取reflect.Value 类型
	val := reflect.ValueOf(a)
	//获取到a对应的类别
	kd := val.Kind()
	//如果传入的不是struct，就退出
	if kd !=  reflect.Struct 
		fmt.Println("expect struct")
		return
	

	//获取到该结构体有几个字段
	num := val.NumField()

	fmt.Printf("struct has %d fields\\n", num) //4
	//变量结构体的所有字段
	for i := 0; i < num; i++ 
		fmt.Printf("Field %d: 值为=%v\\n", i, val.Field(i))
		//获取到struct标签, 注意需要通过reflect.Type来获取tag标签的值
		tagVal := typ.Field(i).Tag.Get("json")
		//如果该字段于tag标签就显示，否则就不显示
		if tagVal != "" 
			fmt.Printf("Field %d: tag为=%v\\n", i, tagVal)
		
	
	
	//获取到该结构体有多少个方法
	numOfMethod := val.NumMethod()
	fmt.Printf("struct has %d methods\\n", numOfMethod)
	
	//var params []reflect.Value
	//方法的排序默认是按照 函数名的排序（ASCII码）
	val.Method(1).Call(nil) //获取到第二个方法。调用它

	
	//调用结构体的第1个方法Method(0)
	var params []reflect.Value  //声明了 []reflect.Value
	params = append(params, reflect.ValueOf(10))
	params = append(params, reflect.ValueOf(40))
	res := val.Method(0).Call(params) //传入的参数是 []reflect.Value, 返回[]reflect.Value
	fmt.Println("res=", res[0].Int()) //返回结果, 返回的结果是 []reflect.Value*/


func main() 
	//创建了一个Monster实例
	var a Monster = Monster
		Name:  "黄鼠狼精",
		Age:   400,
		Score: 30.8,
	
	//将Monster实例传递给TestStruct函数
	TestStruct(a)

) 使用反射的方式来获取结构体的tag标签, 遍历字段的值，修改字段值，调用结构体方法(要求：通过传递地址的方式完成, 在前面案例上修改即可)

3 ) 定义了两个函数test 1 和test 2 ，定义一个适配器函数用作统一处理接口【了解】

4 ) 使用反射操作任意结构体类型：【了解】

5 ) 使用反射创建并操作结构体

十八、TCP编程

Golang的主要设计目标之一就是面向大规模后端服务程序，网络通信这块是服务端程序必不可少也是至关重要的一部分。

网络编程有两种:

1 ) TCPsocket编程，是网络编程的主流。之所以叫Tcpsocket编程，是因为底层是基于Tcp/ip协议的. 比如:QQ聊天 [示意图]

2 ) b/s结构的http编程，我们使用浏览器去访问服务器时，使用的就是http协议，而http底层依旧是用tcpsocket实现的。[示意图] 比如: 京东商城【这属于goweb 开发范畴】

18.1 TCP/IP协议

TCP/IP（TransmissionControlProtocol/InternetProtocol)的简写,中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议、Internet国际互联网络的基础，简单地说，就是由网络层的IP协议和传输层的TCP协议组成的。

18.2 端口

这里所指的端口不是指物理意义上的端口，而是特指TCP/IP协议中的端口，是逻辑意义上的端口。

如果把IP地址比作一间房子，端口就是出入这间房子的门。真正的房子只有几个门，但是一个IP地址的端口可以有 65536 （即： 256 × 256 ）个之多！端口是通过端口号来标记的，端口号只有整数，范围是从 0 到 65535 （ 256 × 256 - 1 ）

端口分类

0 号是保留端口.
1 - 1024 是固定端口(程序员不要使用)

又叫有名端口,即被某些程序固定使用,一般程序员不使用.

22 :SSH远程登录协议 23 :telnet使用 21 :ftp使用 25 :smtp服务使用 80 :iis使用 7 :echo服务
1025 - 65535 是动态端口,这些端口，程序员可以使用.

端口注意事项

1 ) 在计算机(尤其是做服务器)要尽可能的少开端口

2 ) 一个端口只能被一个程序监听

3 ) 如果使用 netstat –an 可以查看本机有哪些端口在监听

4 ) 可以使用 netstat –anb 来查看监听端口的pid,在结合任务管理器关闭不安全的端口

18.3 socket编程

18.3.1 服务端的处理流程

1 ) 监听端口 8888

2 ) 接收客户端的tcp链接，建立客户端和服务器端的链接

3 ) 创建 goroutine ，处理该链接的请求(通常客户端会通过链接发送请求包)

18.3.2 客户端的处理流程

1 ) 建立与服务端的链接

2 ) 发送请求数据[终端]，接收服务器端返回的结果数据

3 ) 关闭链接

18.3.3 代码实现

程序框架图示意图

服务器端功能:

编写一个服务器端程序，在 8888 端口监听
可以和多个客户端创建链接
链接成功后，客户端可以发送数据，服务器端接受数据，并显示在终端上
先使用telnet 来测试，然后编写客户端程序来测试
- 服务端的代码:

package main
import (
	"fmt"
	"net" //做网络socket开发时,net包含有我们需要所有的方法和函数
	_"io"
)

func process(conn net.Conn) 

	//这里我们循环的接收客户端发送的数据
	defer conn.Close() //关闭conn

	for 
		//创建一个新的切片
		buf := make([]byte, 1024)
		//conn.Read(buf)
		//1. 等待客户端通过conn发送信息
		//2. 如果客户端没有wrtie[发送]，那么协程就阻塞在这里
		//fmt.Printf("服务器在等待客户端%s 发送信息\\n", conn.RemoteAddr().String())
		n , err := conn.Read(buf) //从conn读取
		if err != nil 
			
			fmt.Printf("客户端退出 err=%v", err)
			return //!!!
		
		//3. 显示客户端发送的内容到服务器的终端
		fmt.Print(string(buf[:n])) 
	



func main() 

	fmt.Println("服务器开始监听....")
	//net.Listen("tcp", "0.0.0.0:8888")
	//1. tcp 表示使用网络协议是tcp
	//2. 0.0.0.0:8888 表示在本地监听 8888端口
	listen, err := net.Listen("tcp", "0.0.0.0:8888")
	if err != nil 
		fmt.Println("listen err=", err)
		return 
	
	defer listen.Close() //延时关闭listen

	//循环等待客户端来链接我
	for 
		//等待客户端链接
		fmt.Println("等待客户端来链接....")
		conn, err := listen.Accept()
		if err != nil 
			fmt.Println("Accept() err=", err)
			
		 else 
			fmt.Printf("Accept() suc con=%v 客户端ip=%v\\n", conn, conn.RemoteAddr().String())
		
		//这里准备其一个协程，为客户端服务
		go process(conn)
	
	
	//fmt.Printf("listen suc=%v\\n", listen)

客户端功能:

编写一个客户端端程序，能链接到服务器端的 8888 端口
客户端可以发送单行数据，然后就退出
能通过终端输入数据(输入一行发送一行), 并发送给服务器端 []
在终端输入exit,表示退出程序.

package main
import (
	"fmt"
	"net"
	"bufio"
	"os"
	"strings"
)

func main() 

	conn, err := net.Dial("tcp", "192.168.20.253:8888")
	if err != nil 
		fmt.Println("client dial err=", err)
		return 
	
	//功能一：客户端可以发送单行数据，然后就退出
	reader := bufio.NewReader(os.Stdin) //os.Stdin 代表标准输入[终端]

	for 

		//从终端读取一行用户输入，并准备发送给服务器
		line, err := reader.ReadString('\\n')
		if err != nil 
			fmt.Println("readString err=", err)
		
		//如果用户输入的是 exit就退出
		line = strings.Trim(line, " \\r\\n")
		if line == "exit" 
			fmt.Println("客户端退出..")
			break
		

		//再将line 发送给 服务器
		_, err = conn.Write([]byte(line + "\\n"))
		if err != nil 
			fmt.Println("conn.Write err=", err)

Go语言精修（尚硅谷笔记）第十六章

十六、goroutine和channel

16.1 goroutine线程-基本介绍

进程就是程序在操作系统中的一次执行过程，是系统进行资源分配和调度的基本单位
线程是进程的一个执行实例，是程序执行的最小单元，它是比进程更小的能独立运行的基本单位
一个进程可以创建销毁多个线程，同一个进程中的多个线程可以并发执行
一个程序至少一个进程，一个进程至少一个线程

并发和并行

1 ) 多线程程序在单核上运行，就是并发

2 ) 多线程程序在多核上运行，就是并行

并发：因为是在一个cpu上，比如有10个线程，每个线程执行10毫秒（进行轮询操作），从人的角度看，好像这10个线程都在运行，但是从微观上看，在某一个时间点看，其实只有一个线程在执行，这就是并发。

并行：因为是在多个cpu上（比如有10个cpu），比如有10个线程，每个线程执行10毫秒（各自在不同cpu上执行），从人的角度看，这10个线程都在运行，但是从微观上看，在某一个时间点看，也同时有10个线程在执行，这就是并行。

16.2 Go协程和Go主线程

Go主线程(有程序员直接称为线程/也可以理解成进程): 一个Go线程上，可以起多个协程，你可以这样理解，协程是轻量级的线程[编译器做优化]。
Go协程的特点

1 ) 有独立的栈空间

2 ) 共享程序堆空间

3 ) 调度由用户控制

4 ) 协程是轻量级的线程
一个示意图

请编写一个程序，完成如下功能:

1 ) 在主线程(可以理解成进程)中，开启一个goroutine, 该协程每隔 1 秒输出 “hello,world”

2 ) 在主线程中也每隔一秒输出"hello,golang", 输出 10 次后，退出程序

3 ) 要求主线程和goroutine同时执行

4 ) 画出主线程和协程执行流程图

package main
import (
	"fmt"
	"strconv"
	"time"
)

// 在主线程(可以理解成进程)中，开启一个goroutine, 该协程每隔1秒输出 "hello,world"
// 在主线程中也每隔一秒输出"hello,golang", 输出10次后，退出程序
// 要求主线程和goroutine同时执行

//编写一个函数，每隔1秒输出 "hello,world"
func test() 
	for i := 1; i <= 10; i++ 
		fmt.Println("tesst () hello,world " + strconv.Itoa(i))
		time.Sleep(time.Second)
	


func main() 

	go test() // 开启了一个协程

	for i := 1; i <= 10; i++ 
		fmt.Println(" main() hello,golang" + strconv.Itoa(i))
		time.Sleep(time.Second)

输出的效果说明，main这个主线程和 test 协程同时执行

 main() hello,golang1
tesst () hello,world 1
 main() hello,golang2
tesst () hello,world 2
 main() hello,golang3
tesst () hello,world 3
 main() hello,golang4
tesst () hello,world 4
 main() hello,golang5
tesst () hello,world 5
 main() hello,golang6
tesst () hello,world 6
 main() hello,golang7
tesst () hello,world 7
 main() hello,golang8
tesst () hello,world 8
 main() hello,golang9
tesst () hello,world 9
 main() hello,golang10
tesst () hello,world 10

协程特点

1 ) 主线程是一个物理线程，直接作用在cpu上的。是重量级的，非常耗费cpu资源。

2 ) 协程从主线程开启的，是轻量级的线程，是逻辑态。对资源消耗相对小。

3 ) Golang的协程机制是重要的特点，可以轻松的开启上万个协程。其它编程语言的并发机制是一般基于线程的，开启过多的线程，资源耗费大，这里就突显Golang在并发上的优势了

16.3 MPG模式基本介绍

M:操作系统的主线程（是物理线程）
P:协程执行需要的上下文
G：协程

16.3.1 MPG模式运行的状态 1

当前程序有三个M，如果三个M都在一个cpu运行，就是并发，如果在不同的cpu运行就是并行
M1，M2，M3正在执行一个G，M1的协程队列有三个，M2的协程队列有3个，M3协程队列有2个
从上图可以看到:Go的协程是轻量级的线程，是逻辑态的，Go可以容易的起上万个协程。
其他程序c/java的多线程，往往是内核态的，比较重量级，几千个线程可能耗光cpu

16.3.2 MPG模式运行的状态 2

设置GOLANG运行的CPU数
为了充分了利用多cpu的优势，在Golang程序中，设置运行的cpu数目

package main
import (
	"runtime"
	"fmt"
)

func main() 
	cpuNum := runtime.NumCPU()
	fmt.Println("cpuNum=", cpuNum)

	//可以自己设置使用多个cpu
	runtime.GOMAXPROCS(cpuNum - 1)
	fmt.Println("ok")

go1.8后，默认让程序运行在多个核上，可以不用设置了
go1.8前，还是要设置以下，可以更高效的利用cpu

16.4 channel管道介绍

使用goroutine 来完成，效率高，但是会出现并发/并行安全问题

package main
import (
	"fmt"
	"time"
)

// 需求：现在要计算 1-200 的各个数的阶乘，并且把各个数的阶乘放入到map中。
// 最后显示出来。要求使用goroutine完成 

// 思路
// 1. 编写一个函数，来计算各个数的阶乘，并放入到 map中.
// 2. 我们启动的协程多个，统计的将结果放入到 map中
// 3. map 应该做出一个全局的.

var (
	myMap = make(map[int]int, 10)  
)

// test 函数就是计算 n!, 让将这个结果放入到 myMap
func test(n int) 
	
	res := 1
	for i := 1; i <= n; i++ 
		res *= i
	

	//这里我们将 res 放入到myMap
	myMap[n] = res //concurrent map writes?


func main() 

	// 我们这里开启多个协程完成这个任务[200个]
	for i := 1; i <= 200; i++ 
		go test(i)
	


	//休眠10秒钟【第二个问题 】
	time.Sleep(time.Second * 10)

	//这里我们输出结果,变量这个结果
	for i, v := range myMap 
		fmt.Printf("map[%d]=%d\\n", i, v)

这里就提出了不同goroutine如何通信的问题
- 1 ) 全局变量的互斥锁
- 2 ) 使用管道channel来解决

16.4.1 全局变量加锁同步改进程序

因为没有对全局变量 m 加锁，因此会出现资源争夺问题，代码会出现错误，提示concurrent map writes
解决方案：加入互斥锁
我们的数的阶乘很大，结果会越界,可以将求阶乘改成 sum+=uint 64 (i)

package main
import (
	"fmt"
	_ "time"
	"sync"
)

// 需求：现在要计算 1-200 的各个数的阶乘，并且把各个数的阶乘放入到map中。
// 最后显示出来。要求使用goroutine完成 

// 思路
// 1. 编写一个函数，来计算各个数的阶乘，并放入到 map中.
// 2. 我们启动的协程多个，统计的将结果放入到 map中
// 3. map 应该做出一个全局的.

var (
	myMap = make(map[int]int, 10)  
	//声明一个全局的互斥锁
	//lock 是一个全局的互斥锁， 
	//sync 是包: synchornized 同步
	//Mutex : 是互斥
	lock sync.Mutex
)

// test 函数就是计算 n!, 让将这个结果放入到 myMap
func test(n int) 
	
	res := 1
	for i := 1; i <= n; i++ 
		res *= i
	

	//这里我们将 res 放入到myMap
	//加锁
	lock.Lock()
	myMap[n] = res //concurrent map writes?
	//解锁
	lock.Unlock()


func main() 

	// 我们这里开启多个协程完成这个任务[200个]
	for i := 1; i <= 20; i++ 
		go test(i)
	

	//休眠10秒钟【第二个问题 】
	//time.Sleep(time.Second * 5)

	//这里我们输出结果,变量这个结果
	lock.Lock()
	for i, v := range myMap 
		fmt.Printf("map[%d]=%d\\n", i, v)
	
	lock.Unlock()

16.4.2 为什么需要channel

前面使用全局变量加锁同步来解决goroutine的通讯，但不完美
主线程在等待所有goroutine全部完成的时间很难确定，我们这里设置 10 秒，仅仅是估算。
如果主线程休眠时间长了，会加长等待时间，如果等待时间短了，可能还有goroutine处于工作状态，这时也会随主线程的退出而销毁
通过全局变量加锁同步来实现通讯，也并不利用多个协程对全局变量的读写操作。
上面种种分析都在呼唤一个新的通讯机制-channel

16.4.3 channel介绍

channle本质就是一个数据结构-队列【示意图】
数据是先进先出【FIFO:firstinfirstout】
线程安全，多goroutine访问时，不需要加锁，就是说channel本身就是线程安全的
channel有类型的，一个string的channel只能存放string类型数据。
示意图：

定义声明channel

var 变量名 chan 数据类型

举例：

var intChan chan int(intChan用于存放int数据)
var mapChan chan map[int]string(mapChan用于存放map[int]string类型)
var perChan chan Person
var perChan2 chan *Person

说明

channel是引用类型
channel必须初始化才能写入数据, 即make后才能使用
管道是有类型的，intChan 只能写入整数 int

16.5 管道初始化写入数据读出数据

package main
import (
	"fmt"
)

func main() 

	//演示一下管道的使用
	//1. 创建一个可以存放3个int类型的管道
	var intChan chan int
	intChan = make(chan int, 3)

	//2. 看看intChan是什么
	fmt.Printf("intChan 的值=%v intChan本身的地址=%p\\n", intChan, &intChan)


	//3. 向管道写入数据
	intChan<- 10
	num := 211
	intChan<- num
	intChan<- 50
	// //如果从channel取出数据后，可以继续放入
	<-intChan
	intChan<- 98//注意点, 当我们给管写入数据时，不能超过其容量

	//4. 看看管道的长度和cap(容量)
	fmt.Printf("channel len= %v cap=%v \\n", len(intChan), cap(intChan)) // 3, 3

	//5. 从管道中读取数据

	var num2 int
	num2 = <-intChan 
	fmt.Println("num2=", num2)
	fmt.Printf("channel len= %v cap=%v \\n", len(intChan), cap(intChan))  // 2, 3

	//6. 在没有使用协程的情况下，如果我们的管道数据已经全部取出，再取就会报告 deadlock

	num3 := <-intChan
	num4 := <-intChan

	//num5 := <-intChan

	fmt.Println("num3=", num3, "num4=", num4/*, "num5=", num5*/)

16.6 管道阻塞

什么时候阻塞

向一个值为nil的管道写或读数据
无缓冲区时单独的写或读数据
缓冲区为空时进行读数据
缓冲区满时进行写数据

常见错误

关闭值为nil的管道
关闭已经关闭的管道
往已经close的管道发送数据会panic

**注意：

从已关闭的通道接收数据时将不会发生阻塞

由此可见通道如果不主动close掉，读出通道全部数据后该协程就会阻塞

从已经关闭的通道接收数据或者正在接收数据时，将会接收到通道类型的零值，然后停止阻塞并返回。

16.7 注意事项

channel中只能存放指定的数据类型
channle的数据放满后，就不能再放入了
如果从channel取出数据后，可以继续放入
在没有使用协程的情况下，如果channel数据取完了，再取，就会报deadlock

使用例子

1）创建一个intChan，最多可以存放3个int，演示存3数据到intChan，然后再取出这三个int

package main

import (
	"fmt"
)

func main() 
	var intChan chan int
	intChan = make(chan int, 3)
	intChan <- 10
	intChan <- 20
	intChan <- 10
	//因为intChan 的容量为3，再存放会报deadlock
	//intChan <- 50
	num1 := <-intChan
	num2 := <-intChan
	num3 := <-intChan
	//因为intChan 这时已经没有数据了，再取就会报deadlock
	//num3 := <- intChan
	fmt.Printf("num1=%v num2=%v num3=%v", num1, num2, num3)

2）创建一个mapChan，最多可以存放10个map[string]string的key-val，演示写入和读取

package main

import (
	"fmt"
)

func main() 
	var mapChan chan map[string]string
	mapChan = make(chan map[string]string, 10)
	m1 := make(map[string]string, 20)
	m1["city1"] = "北京"
	m1["city2"] = "天津"

	m2 := make(map[string]string, 20)
	m2["hero1"] = "宋江"
	m2["hero2"] = "武松"

	mapChan <- m1
	mapChan <- m2

	m11 := <-mapChan
	m22 := <-mapChan

	fmt.Println(m11, m22)

3）创建一个catChan，最多可以存放10个Cat结构体变量

package main

import (
	"fmt"
)

type Cat struct 
	Name string
	Age  byte


func main() 
	var catChan chan Cat
	catChan = make(chan Cat, 10)
	cat1 := CatName: "tom", Age: 18
	cat2 := CatName: "tom~", Age: 180

	catChan <- cat1
	catChan <- cat2

	//取出
	cat11 := <-catChan
	cat22 := <-catChan

	fmt.Println(cat11, cat22)

4）创建一个catChan2，最多可以存放10个*Cat变量，演示写入和读取的方法

package main

import (
	"fmt"
)

type Cat struct 
	Name string
	Age  byte


func main() 
	var catChan chan *Cat
	catChan = make(chan *Cat, 10)
	cat1 := CatName: "tom", Age: 18
	cat2 := CatName: "tom~", Age: 180

	catChan <- &cat1
	catChan <- &cat2

	//取出
	cat11 := <-catChan
	cat22 := <-catChan

	fmt.Println(cat11, cat22)

5）创建一个allChan，最多可以存放10个任意数据类型变量，演示写入和读取的用法

package main

import (
	"fmt"
)

type Cat struct 
	Name string
	Age  byte


func main() 

	var allChan chan interface
	allChan = make(chan interface, 10)

	cat1 := CatName: "tom", Age: 18
	cat2 := CatName: "tom~", Age: 180

	allChan <- cat1
	allChan <- cat2
	allChan <- 10
	allChan <- "jack"

	//取出
	cat11 := <-allChan
	cat22 := <-allChan
	v1 := <-allChan
	v2 := <-allChan

	fmt.Println(cat11, cat22, v1, v2)

6）看下面代码，会输出什么？

package main

import (
	"fmt"
)

type Cat struct 
	Name string
	Age  byte


func main() 

	var allChan chan interface
	allChan = make(chan interface, 10)

	cat1 := CatName: "tom", Age: 18

	allChan <- cat1

	//取出
	newCat := <-allChan //从管道中取出的cat是什么？
	fmt.Printf("newCat=%T,newCat=%v\\n", newCat, newCat)
	//下面的写法是错误的！编译不通过
	//fmt.Printf("newCat.Name=%v",newCat.Name)

	//使用类型断言
	a := newCat.(Cat)
	fmt.Printf("newCat.Name=%v", a.Name)

channel可以声明为只读，或者只写性质

package main
import (
	"fmt"
)

func main() 
	//管道可以声明为只读或者只写

	//1. 在默认情况下下，管道是双向
	//var chan1 chan int //可读可写
	
	//2 声明为只写
	var chan2 chan<- int
	chan2 = make(chan int, 3)
	chan2<- 20
	//num := <-chan2 //error

	fmt.Println("chan2=", chan2)

	//3. 声明为只读
	var chan3 <-chan int
	num2 := <-chan3
	//chan3<- 30 //err
	fmt.Println("num2", num2)

channel只读和只写的最佳实践案例

package main

import (
	"fmt"
)

// ch chan<- int,这样ch就只能写操作
func send(ch chan<- int, exitChan chan struct) 
	for i := 0; i < 10; i++ 
		ch <- i
	
	close(ch)
	var a struct
	exitChan <- a


// ch <-chan int,这样ch就只能读操作
func recv(ch <-chan int, exitChan chan struct) 
	for 
		v, ok := <-ch
		if !ok 
			break
		
		fmt.Println(v)
	
	var a struct
	exitChan <- a


func main() 
	var ch chan int
	ch = make(chan int, 10)
	exitChan := make(chan struct, 2)
	go send(ch, exitChan)
	go recv(ch, exitChan)

	var total = 0
	for _ = range exitChan 
		total++
		if total == 2 
			break
		
	
	fmt.Println("结束。。。")

16.7.8 select：可以解决从管道取数据的阻塞问题

select是go语言当中提供的一个选择语句。select的语法类似switch语句，也属于控制语句。

那为什么select语句我们没有放在和if、switch语句一起？

因为select是配合channel通道使用的。每个 case 必须是一个通信操作，要么是发送要么是接收。

select特性

select只能用于channel操作，每个case都必须是一个channel；
如果有多个case可以允许（channel没有阻塞），则随机选择一条case语句执行；
如果没有case语句可以执行（channel发生阻塞），切没有default语句，则select语句会阻塞；
如果没有case语句可以执行（channel发生阻塞），有default语句，则执行default语句；

一般使用超时语句代替default语句；

func main() 
	ch1 := make(chan int)
	ch2 := make(chan int)
 
	select 
	case num1 := <-ch1:
		fmt.Println("ch1中的数据是:", num1)
	case num2 := <-ch2:
		fmt.Println("ch2中的数据是:", num2)
	case <-time.After(3 * time.Second):
		fmt.Println("timeout...")

如果case语句中的channel为nil，则忽略该分支，相当于从select中删除了该分支；
如果select语句在for循环中，一般不使用default语句，因为会引起CPU占用过高问题。

select语法格式

select 
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s);
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);

例子：

package main
import (
	"fmt"
	"time"
)

func main() 

	//使用select可以解决从管道取数据的阻塞问题

	//1.定义一个管道 10个数据int
	intChan := make(chan int, Go语言精修（尚硅谷笔记）第五章
 《深入浅出Mysql》——第三篇 优化篇 第十七章 常用SQL技巧和常见问题 + 第十八章 SQL优化 + 第十九章 优化数据库对象
 Linux内核设计与实现读书笔记——第十八章
 第十八章读书笔记
 《linux内核设计与实现》读书笔记第十八章
 C语言第十八章：shell脚本