Golang语法特性总结

1.认识Golang代码特性

package main //1.包含main函数的文件就是一个main包--当前程序的包名

// import "fmt"
// import "time"
import(
	"fmt"
	"time"
)//3.同时包含多个包 4.强制代码风格:函数的 { 一定和函数名在同一行，否则会出现语法错误

//main函数
func main() {
	fmt.Println("hello Go!")
	// fmt.Println("hello Go!"); 2.加不加分号都可以，建议不加分号
	time.Sleep(1 * time.Second)
}

2.Golang变量声明的四种方式

package main

import (
	"fmt"
)

func main() {
	//方法一：声明一个变量，不初始化默认是0
	var a int
	fmt.Println("a =",a)
	fmt.Printf("type of a = %T\n",a)


	//方法二：声明一个变量，初始化
	var b int = 100
	fmt.Println("b =",b)
	fmt.Printf("type of b = %T\n",b)
	var bb string = "abcd"
	fmt.Printf("bb = %s,type of bb = %T\n",bb,bb)

	//方法三：在初始化时可以省去数据类型，通过值自动匹配当前的变量的数据类型
	var c = 100
	fmt.Println("c =",c)
	fmt.Printf("type of c = %T\n",c)
	var cc = "abcd"
	fmt.Printf("cc = %s,type of cc = %T\n",cc,cc)

	//方法四：(常用的方法)省去var的关键字，直接:=自动匹配;在声明的变量是全局变量时，方法四是不可用的会报错
	e := 100
	fmt.Println("e =",e)
	fmt.Printf("type of e = %T\n",e)
	ee := "abcd"
	fmt.Printf("ee = %s,type of ee = %T\n",ee,ee)
	eee := 3.14
	fmt.Printf("eee = %s,type of eee = %T\n",eee,eee)

	//声明多个变量
	var xx,yy int = 100,200 //相同数据类型
	fmt.Println("xx =",xx," yy =",yy)
	var mm,nn = 100,"abcd" //不同数据类型
	fmt.Println("mm =",mm," nn =",nn)

	//多行的多变量声明
	var (
		vv int = 100
		jj bool = true
	)
	fmt.Println("vv =",vv," jj =",jj)
}

3.常量与iota

package main

//const 来定义枚举类型
const (
	//可以在const()添加一个关键字 iota，每行的iota都会累加1，第一行的iota的默认值是0
	BEIJING = iota //iota = 0
	SHANGHAI	   //iota = 1
	SHENZHEN 	   //iota = 2
)
//iota只能出现在const的括号中
const (
	a,b = iota+1,iota+2// 0+1,0+2
	c,d				   // 1+1,1+2
	e,f				   // 2+1,2+2
	g,h = iota*2,iota*3// 3*2,3*3
	i,k				   // 4*2,4*3
)
func main()
{
	//常量-具有只读属性
	const length int = 10
	fmt.Println("length = ",length)
	length = 100 //报错-常量不可更改
}

4.Golang多返回值的三种写法

package main
import "fmt"

func fool(a string,b int) int {
	fmt.Println("a = ",a)
	fmt.Println("b = ",b)
	c := 100
	return c
}

//1.返回多个返回值-匿名
func foo2(a string,b int) (int,int) {
	fmt.Println("a = ",a)
	fmt.Println("b = ",b)
	return 666,777
}

//2.返回多个返回值-有形参名称
func foo3(a string,b int) (r1 int,r2 int) {
	fmt.Println("------------foo3-----------")
	fmt.Println("a = ",a)
	fmt.Println("b = ",b)
	r1 = 1000
	r2 = 2000
	return r1,r2
	//return;  方法3--也可以返回r1,r2
}

func main() {
	c := fool("abc",555)
	fmt.Println("c = ",c)
	ret1,ret2 := foo2("bfr",666)
	fmt.Println("ret1 = ",ret1,"ret2 = ",ret2)
	ret3,ret4 := foo3("grx",777)
	fmt.Println("ret3 = ",ret3,"ret4 = ",ret4)
}

5.init函数与import导包

递归式导包直到最后一个包没有依赖包->加载该包全局的常量变量->执行init函数

"主程序开始之前，加载一些配置文件、加载一些数据库的内容、基本环境变量的初始化"

package main

import(
	"GolangStudy/Golang_5/lib1"
	"GolangStudy/Golang_5/lib2"
)

func main(){
	lib1.LibTest()
	lib2.LibTest()
}

package lib1

import "fmt"

//API接口
func LibTest() {
	fmt.Println("Lib1Test.....")
}
//init初始化函数
func init() {
	fmt.Println("Lib1init.....")
}

package lib2

import "fmt"

//API接口--大写首字母表示对外开放该接口
func LibTest() {
	fmt.Println("Lib2Test.....")
}
//init初始化函数
func init() {
	fmt.Println("Lib2init.....")
}

运行结果：

三种导包的方式：

//三种导包的方式
import(
	_ "GolangStudy/Golang_5/lib1" //_表示匿名，可以在不使用该包但是可以调用它的init函数-无法使用当钱包的方法
	//mylib "GolangStudy/Golang_5/lib2" //给包起别名mylib
	. "GolangStudy/Golang_5/lib2" // . 表示将该包直接导入main包直接使用
)

func main(){
	//lib1.LibTest()
	//lib2.LibTest()
	//mylib.LibTest()
	LibTest()//同名方法容易导致歧义
}

6.Golang中指针的使用

package main
import "fmt"

func swap(pa *int, pb *int) {
	var tem int;
	tem = *pa  
	*pa = *pb
	*pb = tem
}

func main() {
	var a int = 10
	var b int = 20
	swap(&a,&b)
	fmt.Println("a = ",a,"b = ",b)

	var p *int
	p = &a
	fmt.Println("p = ",p)
	var pp **int = &p
	fmt.Println("pp = ",pp)
}

7.Golang中的defer语句

package main
import "fmt"

func main(){
	//写入defer关键字--类似C++中的析构函数--出它作用域时会调用
	defer fmt.Println("main end1")//先入栈
	defer fmt.Println("main end2")//再入栈

	fmt.Println("main run1")
	fmt.Println("main run2")
}

输出结果：

defer和return的执行顺序

func deferFunc() int{
	fmt.Println("defer func called...")
	return 0
}
func returnFunc() int{
	fmt.Println("return func called...")
	return 0
}
func rad() int {
	defer deferFunc()
	return returnFunc()
}
func main() {
	rad()
}

输出结果： return比defer先执行

8.Golang中的数组

---静态数组

静态数组传参是值拷贝传参，并且只能接收特定格式的数组确定元素类型与元素个数

package main
import "fmt"

//值拷贝传参，将实参数组拷贝给形参
func printArray(myArray [10]int) { //只能接收1、2即int[10]数据类型
	for index,value:=range myArray {
		fmt.println(index," ",value)
	}
}
func printArray(myArray [4]int) {  只能接收3即int[4]数据类型
	for index,value:=range myArray {
		fmt.println(index," ",value)
	}
}

func main(){
	//固定长度的数组
	var myArray1 [10]int
	myArray2 := [10]int{1,2,3,4}
	myArray3 := [4]int{1,2,3,4}

	//for i:= 0; i<10; i++
	for i:=0; i<len(myArray1); i++{
		fmt.println(myArray1[i])
	}
	for index,value:=range myArray1 {
		fmt.println(index," ",value)
	}
	//查看数组的数据类型
	fmt.printf("myArray1 types = %T\n",myArray1)
	fmt.printf("myArray2 types = %T\n",myArray2)
	fmt.printf("myArray3 types = %T\n",myArray3)
}

---动态数组(slice切片)

package main
import "fmt"

//动态数组具有传参上的优势
//传递的是当前数组的指针首地址，引用传递
func printArray(myArray []int) {
	// _ 表示匿名的变量
	for _, value := range myArray {//不关心下标，但必须用两个接收
		fmt.Println("value = ",value)
	}
	myArray[0] = 100
}

func main() {
	myArray := []int{1,2,3,4} //动态数组,切片 slice
	fmt.Printf("myArray type is %T\n",myArray)//输出：myArray type is []int
	printArray(myArray)
	for _, value := range myArray {
		fmt.Println("value = ",value)
	}
}

---四种声明一个切片的方式

func main () {
	//声明slice是一个切片，并且初始化，默认值是1，2，3；长度len是3
	slice := []int{1,2,3}
	
	//声明slice1是一个切片，但没有给它分配空间
	var slice1 []int  //此时长度就是0
	slice1 = make([]int,3)//通过make给slice1分配空间，默认值是0

	//声明slice2是一个切片，同时通过make给slice2分配空间，默认值是0
	var slice2 []int = make([]int,3)

	//声明slice3是一个切片,同时分配空间，通过:=推导出slice是一个切片
	slice := make([]int,3)

	fmt.Printf("len = %d,slice = %v\n",len(slice1),slice1)

	//判断一个slice是否为0
	if slice == nil {
		fmt.printf("slice是一个空切片")
	}else{
		fmt.printf("slice不是一个空切片")
	}
}

---切片容量的追加

func main () {
	var numbers = make([]int,3,5)//开辟五个空间只初始化3个为0
	fmt.Printf("len = %d,cap = %d,numbers = %v\n",len(numbers),cap(numbers),numbers)

	//向numbers切片追加一个1
	numbers = append(numbers,1)
	fmt.Printf("len = %d,cap = %d,numbers = %v\n",len(numbers),cap(numbers),numbers)

	numbers = append(numbers,2)
	fmt.Printf("len = %d,cap = %d,numbers = %v\n",len(numbers),cap(numbers),numbers)

	numbers = append(numbers,3)//会进行2倍扩容
	fmt.Printf("len = %d,cap = %d,numbers = %v\n",len(numbers),cap(numbers),numbers)

	var numbers2 = make([]int,3)//开辟三个空间并全部初始化为0
	fmt.Printf("len = %d,cap = %d,numbers2 = %v\n",len(numbers2),cap(numbers2),numbers2)

	numbers2 = append(numbers2,1)//会进行2倍扩容
	fmt.Printf("len = %d,cap = %d,numbers2 = %v\n",len(numbers2),cap(numbers2),numbers2)
}

输出结果：

---切片的截取

func main () {
	s := []int{1,2,3} //len=3,cap=3

	//[0,2)
	s1 := s[0:2] //取1和2，前面省略表示从第0个开始取，后面省略表示取到最后一个
	fmt.Println(s1)
	
	s1[0] = 100
	fmt.Println(s1) //s1此时也指向s的第一个，相当于浅拷贝
	fmt.Println(s)

	//copy深拷贝，将底层数组的slice一起进行拷贝
	s2 := make([]int,2) //s2 = [0,0,0]

	copy(s2,s1)
	fmt.Println(s2) //可以先将s切片成s1，再进行深拷贝给s2，就可以分离
}

9.Golang中基于哈希的Map

---Map的三种声明定义方式

func main() {
	//第一种声明方式
	var myMap1 map[string]string //仅仅是声明，没有实际的空间,并不能被使用
	if myMap1 == nil {
		fmt.Println("myMap1是一个空map")
	}
	myMap1 = make(map[string]string,10) //用make给Map开辟十个键值对的空间
	myMap1["one"] = "java"
	myMap1["two"] = "C++"
	myMap1["three"] = "python"
	//...当插入十个之后也会二倍扩容

	fmt.Println(myMap1)//打印出来是无序的

	//第二种声明方式
	myMap2 := make(map[int]string)
	myMap2[1] = "java"
	myMap2[2] = "C++"
	myMap2[3] = "python"
	fmt.Println(myMap2)

	//第三种声明方式
	myMap3 := map[int]string {
		4 : "java",
		5 : "C++",
		6 : "python",
	}
	fmt.Println(myMap3)
}

---Map的基本使用

func printMap(cityMap map[string]string) {
	for key,value := range cityMap {
		fmt.Printf("key = %s ",key)
		fmt.Printf("value = %s\n",value)
	}
	cityMap["one"] = "golang"
}

//指向当前map内存结构体地址的指针cityMap

func main() {
	cityMap := make(map[string]string,3)
	//添加
	cityMap["one"] = "java"
	cityMap["two"] = "C++"
	cityMap["three"] = "python"
	//删除
	delete(cityMap,"three")
	//修改
	cityMap["two"] = "php"
	//传参
	printMap(cityMap)
	//遍历
	for key,value := range cityMap {
		fmt.Printf("key = %s ",key)
		fmt.Printf("value = %s\n",value)
	}
}
//将一个map赋值给另一个时只能完成指针之间的浅拷贝，只能通过make开辟一个Map进行遍历赋值

10.struct(类)的定义和使用

---struct类的定义

//声明一种行的数据类型，是Int的一个别名
type myint int 
type Book struct {
	title string
	auth string 
}

func changeBook(book Book) {
	//传递book的一个副本
	book.auth = "666"
}
func changeBook2(book *Book) {
	//传递指向Book结构体的指针
	book.auth = "777"
}

func main() {
	// var a myint = 10
	// fmt.Printf("type = %T",a)

	var book1 Book
	book1.title = "Golang"
	book1.auth = "zhang3"
	fmt.Printf("book1 = %v",book1)
}

---类的封装和方法的调用

//go语言中的类实际上是通过结构体来绑定方法
package main

//方法名、类名如果首字母大写，其它包也可以访问
type Hero struct {
	Name string
	Ad int
	Level int
}

//当前括号表示该方法绑定到了Hero结构体，this表示调用对象，谁调用该方法this就指哪个对象
func (this Hero) GetName() string{
	return this.Name
}

//this是当前调用对象的一个副本
func (this Hero) SetName(newName string) {
	this.Name = newName
}
//此时this就是指向当前对象的指针，就可以修改了
func (this *Hero) SetName(newName string) {
	this.Name = newName
}

func main() {
	//创建一个对象
	hero := Hero{Name: "zhang3",Ad: 100,Level: 1}
}

---继承的基本语法

type Human struct {
	name string
	sex string
}

func (this *Human) Eat() {
	fmt.Println("human Eat().....")
}
func (this *Human) Walk() {
	fmt.Println("human Walk().....")
}

type SuperMan struct {//Go中实际是以组合的形式实现继承
	Human //Superman继承了Human类的所有方法
	level int
}

//重写(覆盖)父类方法
func (this *SuperMan) Eat() {
	fmt.Println("SuperMan Eat().....")
}

//子类的新方法
func (this *SuperMan) Fly() {
	fmt.Println("SuperMan Fly().....")
}

func main() {
	h := Human{"zhang3","female"}
	h.Eat()
	h.Walk
	s := SuperMan{Human{"li4","female"},88}
	// var s SuperMan
	// s.name = "li4"//...
	s.Walk() //子类调用父类的方法
	s.Eat() //子类调用子类重写的方法
	s.Fly() //子类调用子类的新方法
}

---interface实现多态

package main
//面向对象的多态：定义一个接口完成多态的现象;接口定义抽象方法，子类去继承实现重写这个方法

//interface本质上是一个指针，指向当前类型包含的函数列表
type AnimalIF interface {
	Sleep()
	GetColor() string //获取动物的颜色
	GetType() string //获取动物的类型
}

//具体的值--要继承AnimalIF interface只需要将他的三个方法实现，不需要显式继承
type Cat struct {
	color string //猫的颜色
}

func (this *Cat) Sleep() {
	fmt.Println("cat is sleep")
}

func (this *Cat) GetColor() string {
	return this.color
}

func (this *Cat) GetType() string {
	return "cat"
}

//具体的值--狗
type Dog struct {
	color string 
}

func (this *Dog) Sleep() {
	fmt.Println("Dog is sleep")
}

func (this *Dog) GetColor() string {
	return this.color
}

func (this *Dog) GetType() string {
	return "Dog"
}


func showAnimal(animal AnimalIF)//调用该函数，形参为父类指针，实参为子类对象实现多态
{
	animal.Sleep()
}

func main() {
	// var animal AnimalIF //接口的数据类型，相当于定义了一个父类指针
	// animal = &Cat("green") //让父类的指针指向一个子类对象
	// animal.Sleep() //指向子类对象的父类指针调用子类方法实现多态
	cat := Cat("green")
	dog := Dog("yellow")
	showAnimal()
}

---interface{}空接口万能类型

//interface{} 空接口，万能类型-》可以引用任意数据类型
package main

import "fmt"

func myFunc(arg interface{}) { //可以传任意类型的实参
	fmt.Println("myFunc is called..")
	fmt.Println(arg)

	//类型断言
	value,ok := arg.(string) //value是数据值，ok是error
	if !ok {
		fmt.Println("arg is not a string")
	}else{
		fmt.Println("arg is a string")
	}
	fmt.Println(value)
}

type Book struct {
	auth string
}

func main() {
	book := Book{"Golang"}

	myFunc(book)
	myFunc("abcd")
	myFunc(888)
	myFunc(23.45)
}

11.Golang中反射的概念

---接口type interface { }的类型

Golang中一个变量包含一个pair即type和value对。

type分为static type(在编译时就确定并且不会改变)和concrete type(在运行时确定并且会改变)。

var i int           // static type 为 int; 
var i interface{}   // pair()
i = 18             // concrete type 为 int
i = "Go编程时光"   // concrete type 变为 string

type Reader interface {
	ReadBook()
}

type Writer interface {
	WriteBook()
}

//具体类型
type Book struct {
}

func (this *Book) ReadBook() {
	fmt.Println("Read a book.")
}

func (this *Book) WriteBook() {
	fmt.Println("Write a book.")
}

func main() {
	b := &Book{}  //type:*Book  value:0xc000012028

	var r Reader  //concrete type:nil,static type：Reader  value:nil
	r = b         //concrete type:Book*,static type Reader  value:0xc000012028

	r.ReadBook()  //Reader - Book* 多态

	var w Writer  //concrete type:nil,static type：Writer  value:nil
	w = r.(Writer)//类型断言,检查r是否实现了Writer，并将Book*给w
	w.WriteBook()
}

---reflect.ValueOf 和 reflect.TypeOf

package main

import "fmt"
import "reflect"

type User struct {
	Id int//一个filed
	Name string//第二个filed
	Age int		//第三个filed
}

func (this *User) Call() {
	fmt.Println("User is called ...")
	fmt.Println("%v\n",this)
}

func main() {
	user := User{1,"bfr",18}
	DoF(user)
}

func DoF(input interface{}) {
	//获取input的type
	inputType := reflect.TypeOf(input)
	fmt.Println("inputType :",inputType.Name())//?直接打印出当前类型的名称？
	//获取input的value
	inputValue := reflect.ValueOf(input)
	fmt.Println("inputValue :",inputValue)

	//通过type获取里面重要字段
	//通过inputType可以获取NumFiled，进行遍历，就能得到每个filed
	for i := 0;i < inputType.NumField(); i++ {
		field := inputType.Field(i)
		value := inputValue.Field(i).Interface()//?获取字段的值
		fmt.Printf("%s: %v = %v\n",field.Name,field.Type,value)//ID,int,1
	}
	//通过Type获取里面的方法，调用
	for i:=0; i<inputType.NumMethod(); i++ { //遍历User有多少个方法
		m := inputType.Method(i)
		fmt.Printf("%s: %v\n",m.Name,m.Type)
	}
}

12.结构体标签

package main
import "fmt"
import "reflect"

//在不同包中有不同的解释说明
type resume struct {
	Name string `info:"name" doc:"我的名字"`
	Sex string `info:"sex"`
}

func findTag(str interface{}) {
	t := reflect.TypeOf(str).Elem()//Elem当前结构体的全部元素
	for i := 0; i < t.NumField(); i++ {
		taginfo := t.Field(i).Tag.Get("info")
		tagdoc := t.Field(i).Tag.Get("doc")
		fmt.Println("info: ",taginfo," dac:",tagdoc)
	}
}

func main() {
	var res resume
	findTag(&res)
}

//结构体标签-key已知，value未知
type Movie struct {
	Title string `json:"title"` //在json中显示的字段
	Year int	`json:"year"`
	Price int	`json:"price"`
	Actors []string  `json:"actors"`
}

func main() {
	movie := Movie{"喜剧之王",2000,10,[]string{"xingye","zbz"}}
	
	//编码的过程 将结构体->json
	jsonStr,err := json.Marshal(movie)//Marshal可以将结构体转化为json格式
	if err != nil {
		fmt.Println("json marshal error",err)
	}else{
		fmt.Printf("josnStr = %s\n",jsonStr)
	}
	//解码的过程 json->结构体
	myMovie := Movie{}
	err = json.Unmarshal(jsonStr,&myMovie)//将json字符串解析给myMovie结构体
	if err != nil {
		fmt.Println("json unmarshal error",err)
		return
	}
}

13.Golang中的协程:goroutine

---协程的演变发展

---单进程的操作系统只能顺序执行任务，一旦某个任务阻塞，其它任务都不能处理。

---多进程/多线程解决了，CPU调度器进行轮询调度切换进程/线程 ，当某个时间片到了就会切换。但是进程/线程间切换具有成本，一旦数量过大，CPU的++使用效率++ 就会大大降低。进程占4GB左右,线程占用4MB左右，也有++高内存占用++ 的弊端。

---将一个线程拆分，一半在用户层面供用户调用(协程:co-routine)，一半在内核层供CPU调度。

---N : 1，如果有一个协程阻塞，那它的下一个协程就会受到影响。操作系统感知不到用户级协程的存在，无法将阻塞的协程与线程分离，线程资源被完全占用‌

---M : N，利用多核，一个CPU绑定多个线程；解决了某个协程阻塞影响其它协程的问题；通过优化写成调度器优化效率，CPU不做调度。

---Golang对协程的处理

co-routine -> goroutine；将占用内存优化到KB单位(可以大量生产)，(可以灵活调度)。

---通过优化调度器实现灵活调度

package main

import "fmt"
import "time"

func newTask() {
	i:=0
	for { 
		i++
		fmt.Printf("new Goroutine : i = %d\n",i) 
		time.Sleep(1 * time.Second)
	}
}

func main() {
	//创建一个go程 去执行newTask()流程
	go newTask()

	time.Sleep(10*time.Second)
	fmt.Println("main goroutine exit")
	// i:=0

	// for { //死循环main
	// 	i++
	// 	fmt.Printf("main goruntine: i = %d\n",i)
	// 	time.Sleep(1*time.Second)
	// }
}

package main

import "fmt"
import "time"
import "runtime"

func main() {
	//调匿名无参goroutine
	go func() {//匿名方法，直接用Go承载一个形参为空返回值为空的一个函数
		defer fmt.Println("A.defer")

		func() {//仅仅是函数定义
			defer fmt.Println("B.defer")
			//return 
			runtime.Goexit()
			fmt.Println("B")
		}()
		fmt.Println("A")
	}()//调用

	//调匿名有参goroutine
	go func(a int,b int) bool { //并不是阻塞操作，是一个异步操作，不能拿到返回值
		fmt.Println("a = ",a," b = ",b)
		return true
	}(10,20)

	time.Sleep(1*time.Second)
}

14.channel-go语言中协程间通信的机制

---构成死锁：

1.无缓存channel、只写不读或只读不写、导致主线程阻塞。

2.有缓存channel、已满只写不读或为空只读不写、导致主线程阻塞。

package main
import "fmt"
//import "time"

func main() {
	c := make(chan int,3)//带有缓冲的channel
	fmt.Println("len(c) = ",len(c)," cap(c) = ",cap(c))

	go func() {
		defer fmt.Println("子go程结束")
		for i:=0;i<6;i++{
			c <- i
			fmt.Println("running...:","i = ",i," len(c) = ",len(c)," cap(c) = ",cap(c))
		}
	}()

	//time.Sleep(2 * time.Second)
	// for i:=0;i<2;i++ {
	// 	num := <-c //从c中接收数据，并赋值给num
	// 	fmt.Println("num =",num)
	// }
	
	fmt.Println("main 结束")
}

---close关闭channel

关闭channel后，无法向channel再发送数据(再发会引发 panic 错误后导致接收立即返回零值)

关闭channel后，仍旧具有缓存，等读端读完了才会返回。

简单var声明一个channel数据类型，没有进行make，称为nil channel。无论收发都会阻塞。

package main
import "fmt"
func main() {
	c := make(chan int)
	go func() {
		for i:=0;i<5;i++ {
			c <- i
		}
		//close可以关闭一个channel
		close(c)
	}()
	for {
		//ok=true表示channel没有关闭
		if data,ok := <-c; ok { //原子性操作‌：确保通道接收与状态检查在同一个代码块中完成
			fmt.Println(data)
		}else{
			break
		}
	}
	fmt.Println("Main Finished..")
}

---channel 和 range

尝试从c中读数据，range会阻塞等待这个结果；c中有数据range就会返回并进入本轮for循环，没有数据就会阻塞

//可以使用range来迭代不断操作channel
for data := range c { 
		fmt.Println(data)
	}

---channel 和 select

单流体下的一个go只能监视一个channel状态，阻塞监听，select可以解决一个go监听多个channel状态，如果某个channel可读或可写它就会立刻返回。一般会循环进行select监控多个channel。

package main

import "fmt"

func fibo(c,quit chan int){
	x,y := 1,1         //1,1->1; 1,2->1; 
	for{
		select{
		case c <- x: //只要func可读这边就可写
			//如果c可写，则该case就会进来
			t := x
			x = y
			y = t+y
		case <-quit: //只要quit被写入这边就可读就退出
			fmt.Println("quit")
			return
		}
	}
}

func main() {
	c := make(chan int)
	quit := make(chan int)
	go func() {
		for i := 0; i < 6; i++{
			fmt.Println(<-c)//读c
		}
		quit <- 0 //循环结束退出
	}()
	//main go
	fibo(c,quit)
}