1 并发

1.1 goroutine

Goroutine 奉行通过通信来共享内存,而不是共享内存来通信

• goroutine 只是由官方实现的超级“线程池”而已。
• 每个实例 4-5KB 的栈内存占用和由于实现机制而大幅
  减少的创建和销毁开销，是制造 Go 号称的高并发的根本原因。
• goroutine 的简单易用，也在语言层面上给予了开发者巨大的便利

1.2 Channel

• Channel 是 goroutine -沟通的桥梁，大都是阻塞同步的
• 通过 make 创建，close 关闭
• Channel 是引用类型
• 可以使用 for range 来迭代不断操作 channel
• 可以设置单向或双向通道
• 可以设置缓存大小，在未被填满前不会发生阻塞

1.3 Select

• 可处理一个或多个 channel 的发送与接收
• 同时有多个可用的 channel时按随机顺序处理
• 可用空的 select 来阻塞 main 函数
• 可设置超时

package main

import (
	"fmt"
	"runtime"
	"sync"
	"time"
)

func main() {
	testSelectTimeout()
}

func testMain() {
	//当只执行这一句时没有结果输出
	//原因在于go将函数放入其他线程执行，当main结束后其他线程也将结束
	go func() {
		fmt.Println("Go GO GO !!!")
	}()
}

//channel是引用类型，所以不需要传指针类型即可修改
func goFunc(c chan bool) {
	fmt.Println("GO GO GO")
	c <- true
}

//channel
func testChannel() {
	//make(chan bool,x),设置缓存为x
	//当有缓存时，如果缓存还没满则向channel插入值是不会阻塞的
	//创建无缓存的channel
	c := make(chan bool)
	go goFunc(c)
	//此时从channel中取值，如果channel中没有值则将阻塞
	//因此必然将先执行完goFunc然后main才结束
	<-c
}

//channel配合range
func testChannelRange() {
	c := make(chan bool)
	go func() {
		fmt.Println("GO GO GO")
		c <- true
		close(c) //关闭channel，如果不关闭range将一直阻塞main线程
	}()
	for v := range c { //从channel中一直取值，直到channel被关闭
		fmt.Println(v) //输出true
	}
}

//
func testCurrentByChannel() {
	//设置GO使用cup核数,好像默认就是多核
	runtime.GOMAXPROCS(runtime.NumCPU())
	c := make(chan bool, 10)
	f := func(index int) {
		sum := 0
		for i := 0; i < 1000000; i++ {
			sum += i
		}
		fmt.Println(index, sum)
		c <- true
	}
	for i := 0; i < 10; i++ {
		go f(i)
	}
	for i := 0; i < 10; i++ {
		<-c
	}
}

//WaitGroup类似java中的CountDownLatch
func testCurrentByWatiGroup() {
	//设置GO使用cup核数,好像默认就是多核
	runtime.GOMAXPROCS(runtime.NumCPU())
	wg := sync.WaitGroup{}
	wg.Add(10)
	//需要传入指针
	f := func(index int, wg *sync.WaitGroup) {
		sum := 0
		for i := 0; i < 1000000; i++ {
			sum += i
		}
		fmt.Println(index, sum)
		wg.Done()
	}
	for i := 0; i < 10; i++ {
		go f(i, &wg)
	}
	wg.Wait()
}

//有问题。。。。
//当channel都无缓存时关闭其中一个channel，再向另一个写值，此时将发生死锁
//当channel有缓存，关闭的那个channel将一直输出(空,false)
func testSelect() {
	//select 无法保证多个channel都关闭
	c1, c2 := make(chan int), make(chan bool)
	o := make(chan bool)
	go func() {
		//f1, f2 := false, false
		for {
			select {
			//当某个channel关闭后，其case将一直执行，返回一个(v=空值,ok=false)
			//因此此时select将
			case v, ok := <-c1:
				{
					fmt.Println("oc1")
					if !ok {
						fmt.Println("c1")
						o <- true
						break
					}
					fmt.Println("c1", v)
				}
			case v, ok := <-c2:
				{
					if !ok {
						o <- true
						break
					}
					fmt.Println("c2", v)
				}
			}
		}
	}()
	c1 <- 0
	c1 <- 1
	c2 <- true
	c1 <- 2
	c2 <- false
	c1 <- 3

	close(c1)
	//close(c2)
	c2 <- false
	//c2 <- false
	for i := 0; i < 2; i++ {
		<-o
		fmt.Println("o")
	}

}

//select作为发送者
func testSelectSend() {
	c := make(chan int)

	go func() {
		for i := 0; i < 10; i++ {
			//随机向c中写入0或1
			select {
			case c <- 0:
			case c <- 1:
			}
		}
	}()
	for i := 0; i < 10; i++ {
		fmt.Println(<-c)
	}
	select {} //阻塞程序
}

//select timeout
func testSelectTimeout() {
	c := make(chan int)
	go func() {
		for i := 0; i < 5; i++ {
			time.Sleep(1 * time.Second)
			c <- i
		}

	}()
Label:
	for {//不加for则只会输出一次case的匹配就结束了
		select {
		case v := <-c:
			fmt.Println(v)
		case <-time.After(3 * time.Second):	//3s没获取到值时将执行
			fmt.Println("Timeout") //输出
			break Label	//退出select死循环
		}
	}
}