Go语言精修（尚硅谷笔记）第五章
Posted 瞧帆
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Go语言精修（尚硅谷笔记）第五章相关的知识，希望对你有一定的参考价值。
五、程序流程控制
5.1 单分支控制
package main
import (
"fmt"
)
func main()
//请大家看个案例[ifDemo.go]:
//编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,则输出 "你年龄大
//于18,要对自己的行为负责!"
//分析
//1.年龄 ==> var age int
//2.从控制台接收一个输入 fmt.Scanln(&age)
//3.if判断
var age int
fmt.Println("请输入年龄:")
fmt.Scanln(&age)
if age > 18
fmt.Println("你年龄大于18,要对自己的行为负责!")
//golang支持在if中，直接定义一个变量，比如下面
if age := 20; age > 18
fmt.Println("你年龄大于18,要对自己的行为负责!")
5.2 双分支控制
if 条件表达式
执行代码块1
else
执行代码块2
package main
import (
"fmt"
)
func main()
var x int = 4
if x > 2
fmt.Println("ok")
else
fmt.Println("hello")
//编译错误，if没有
package main
import (
"fmt"
)
func main()
var x int = 4
if x > 2
fmt.Println("ok")
else
fmt.Println("hello")
//编译错误，else不能换行
5.3 多分支控制
if 条件表达式1
执行代码块1
else if 条件表达式2
执行代码块2
......
else
执行代码块n
5.4 switch分支控制
1 ) switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上到下逐一测 试，直到匹配为止。
2 ) 匹配项后面也不需要再加 break
switch 表达式
case 表达式1，表达式2，..:
语句块1
fallthrough//穿透 如果有这个则会继续执行下面的case
case 表达式3，表达式4，..:
语句块2
...
default://没有任何case匹配 折执行default 不是必须的
语句块
使用细节
1 ) case/switch后是一个表达式( 即：常量值、变量、一个有返回值的函数等都可以)
2 ) case后的各个表达式的值的数据类型，必须和 switch 的表达式数据类型一致
package main
import (
"fmt"
)
func main()
var n1 int32 = 20
var n2 int64 = 20
switch n1 //错误，原因是n2和n1数据类型不一致
case n2:
fmt.Println("ok1")
default:
fmt.Println("没有匹配到...")
3 ) case后面可以带多个表达式，使用逗号间隔。比如 case 表达式 1 , 表达式 2 …
package main
import (
"fmt"
)
func main()
var n1 int32 = 51
var n2 int32 = 20
switch n1
case n2, 10, 5 : // case 后面可以有多个表达式
fmt.Println("ok1")
case 90 :
fmt.Println("ok2~")
4 ) case后面的表达式如果是常量值(字面量)，则要求不能重复
package main
import (
"fmt"
)
func main()
var n1 int32 = 51
var n2 int32 = 20
switch n1
case n2, 10, 5 : // case 后面可以有多个表达式
fmt.Println("ok1")
case 5 : //错误，前面已经有常量5了，不能重复
fmt.Println("ok2~")
default:
fmt.Println("没有匹配到...")
5.) case后面不需要带break, 程序匹配到一个case后就会执行对应的代码块，然后退出switch，如果一个都匹配不到，则执行 default
6 ) default 语句不是必须的.
7 ) switch 后也可以不带表达式，类似 if–else分支来使用。【案例演示】
package main
import (
"fmt"
)
func main()
//switch 后也可以不带表达式，类似 if --else分支来使用。【案例演示】
var age int = 10
switch
case age == 10 :
fmt.Println("age == 10")
case age == 20 :
fmt.Println("age == 20")
default :
fmt.Println("没有匹配到")
//case 中也可以对 范围进行判断
var score int = 90
switch
case score > 90 :
fmt.Println("成绩优秀..")
case score >=70 && score <= 90 :
fmt.Println("成绩优良...")
case score >= 60 && score < 70 :
fmt.Println("成绩及格...")
default :
fmt.Println("不及格")
8 ) switch 后也可以直接声明/定义一个变量，分号结束，不推荐。 【案例演示】
package main
import (
"fmt"
)
func main()
//switch 后也可以直接声明/定义一个变量，分号结束，不推荐
switch grade := 90; // 在golang中，可以这样写
case grade > 90 :
fmt.Println("成绩优秀~..")
case grade >=70 && grade <= 90 :
fmt.Println("成绩优良~...")
case grade >= 60 && grade < 70 :
fmt.Println("成绩及格~...")
default :
fmt.Println("不及格~")
9 ) switch 穿透-fallthrough ，如果在case语句块后增加fallthrough,则会继续执行下一个case，也 叫switch穿透
package main
import (
"fmt"
)
func main()
//switch 的穿透 fallthrought
var num int = 10
switch num
case 10:
fmt.Println("ok1")
fallthrough //默认只能穿透一层
case 20:
fmt.Println("ok2")
fallthrough
case 30:
fmt.Println("ok3")
default:
fmt.Println("没有匹配到..")
10 ) TypeSwitch：switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际指向的变量类型
package main
import (
"fmt"
)
func main()
var x interface
var y = 10.0
x = y
switch x := x.(type)
case nil:
fmt.Println("x 的类型：%T",i)
case int:
fmt.Println("x 是int型")
case float64:
fmt.Println("x 是float型")
case func(int) float:
fmt.Println("x 是func(int) float") case bool, string:
fmt.Println("x 是bool 或 string型") default:
fmt.Println("未知型..")
5.5 for循环
1）基本语法
for 循环变量初始化; 循环条件; 循环变量迭代
循环操作(语句)
2）for循环的第二种使用方式
for 循环判断条件
//循环执行语句
将变量初始化和变量迭代写到其它位置
案例演示：
package main
import (
"fmt"
)
func main()
//for循环的第二种写法
j := 1 //循环变量初始化
for j <= 10 //循环条件
fmt.Println("你好，Golang Roadmap~", j)
j++ //循环变量迭代
3 ) for循环的第三种使用方式
for
//循环执行语句
上面的写法等价 for;; 是一个无限循环， 通常需要配合 break 语句使用
package main
import (
"fmt"
)
func main()
//for循环的第三种写法, 这种写法通常会配合break使用
k := 1
for // 这里也等价 for ; ;
if k <= 10
fmt.Println("你好，Golang Roadmap~", k)
else
break //break就是跳出这个for循环
k++
4 ) Golang 提供 for-range的方式，可以方便遍历字符串和数组(注: 数组的遍历，我们放到讲数组 的时候再讲解) ，案例说明如何遍历字符串。 字符串遍历方式 1 - 传统方式
package main
import (
"fmt"
)
func main()
//字符串遍历方式1-传统方式
var str string = "hello,world!北京"
for i := 0; i < len(str); i++
fmt.Printf("%c \\n", str[i]) //使用到下标...
字符串遍历方式 2 - for-range
package main
import (
"fmt"
)
func main()
//字符串遍历方式2-for-range
str = "abc~ok上海"
for index, val := range str
fmt.Printf("index=%d, val=%c \\n", index, val)
如果我们的字符串含有中文，那么传统的遍历字符串方式，就是错误，会出现乱码。原因是传统的对字符串的遍历是按照字节来遍历，而一个汉字在utf 8 编码是对应 3 个字节。
如何解决 需要要将 str 转成 []rune切片
package main
import (
"fmt"
)
func main()
//字符串遍历方式1-传统方式
var str string = "hello,world!北京"
str2 := []rune(str) // 就是把 str 转成 []rune
for i := 0; i < len(str2); i++
fmt.Printf("%c \\n", str2[i]) //使用到下标...
对应for-range遍历方式而言，是按照字符方式遍历。因此如果有字符串有中文，也是ok
5.6 WHILE和DO…WHILE的实现
Go语言没有while和do…while语法，这一点需要同学们注意一下，如果我们需要使用类似其它语言(比如 java/c 的 while 和 do…while)，可以通过 for 循环来实现其使用效果。
while循环的实现
循环变量初始化
for
if循环条件表达式
break//跳出for循环
循环操作语句
循环变量迭代
说明上图
1 ) for循环是一个无限循环
2 ) break 语句就是跳出for循环
使用上面的while实现完成输出 10 句”hello,wrold”
package main
import "fmt"
func main()
//使用while方式输出10句 "hello,world"
//循环变量初始化
var i int = 1
for
if i > 10 //循环条件
break // 跳出for循环,结束for循环
fmt.Println("hello,world", i)
i++ //循环变量的迭代
fmt.Println("i=", i)
do…while的实现
循环变量初始化
for
循环操作语句
循环变量迭代
if循环条件表达式
break//跳出for循环
对上图的说明
1 ) 上面的循环是先执行，在判断，因此至少执行一次。
2 ) 当循环条件成立后，就会执行break,break就是跳出for循环，结束循环.
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语言精修（尚硅谷笔记）第十七和十八章