goroutine的使用

1. goroutine的优势:
   当你需要让某个任务并发操作的时候，将任务封装成一个函数，直接使用 go 函数名去进行并发执行，
   go程序就会智能的将goroutine中的任务合理安排给每个CPU去执行，之所以这么方便是因为go已经
   内置了调度和上下文切换机制！
   案例：使用10个线程去执行一个函数，打印Hello
   注意：主函数执行完的话，整个程序都执行结束了，所以得等所有线程都结束才执行主函数
   需要使用syn.WaitGroup进行等待线程执行结束。结束标志就是等wg中的值为0

package main

import (
   "fmt"
   "sync"
)

var wg sync.WaitGroup

func sayHello(){
   defer wg.Done()
   fmt.Println("Hello！")
}


func main() {
   wg.Add(10)
   for i:=0;i<10;i++{
       go sayHello()
   }
   wg.Wait()
   fmt.Println("主函数执行完成！")
}

2. goroutine的原理
   线程由CPU调度是抢占式的，协程由用户态调度是协作式的
   虽然一个goroutine的栈只占几KB，但实际是可伸缩的，如果需要更多内容，runtime会自动为goroutine分配
   goroutine和OS线程是多对多的关系，即m:n

3. goroutine的GOMAXPROCS
   GOMAXPROCS参数用来决定多少个OS线程来同时执行GO代码，默认是CPU的核心数，比如你的电脑是8核的，那么就会把你的Go程序调度到8个线程上去执行
   但是，比如一些日志系统和监控系统，主要就是来监控程序的，如果直接将cup跑满的话，会大大降低程序的执行效率，所以通过设置GOMAXPROCS来设置
   go程序会被几个线程给调度

func a() {
	for i := 1; i < 10; i++ {
		fmt.Println("A:", i)
	}
}

func b() {
	for i := 1; i < 10; i++ {
		fmt.Println("B:", i)
	}
}

func main() {
	runtime.GOMAXPROCS(1)
	go a()
	go b()
	time.Sleep(time.Second)
}

3.channel

1. 为什么使用channel：
   Go语言的并发模型是CSP（Communicating Sequential Processes），提倡通过通信共享内存而不是通过共享内存而实现通信
2. 什么是channel：channel就是一个管道，主要作用就是用来协程之间的通信的
3. 如何使用channel：
   1. 非缓冲channel，就是阻塞channel，如果执行从channel中拿数据的操作，但是没有数据可以拿出来就会阻塞，
      同理：如果往channel中加入数据的话，此时内部有数据，也会一直阻塞，一直到数据别消费，可以成功加入新数据为止
   2. 缓冲channel，在channel没有满的情况下，可以直接存放和取出，不会阻塞！
      定义：var cha = make(chan int 10) 创建一个缓冲区为10的channel
   3. 当通道被关闭时，再往该通道发送值会引发panic
      案例：一个方法拿到数据，放入channel，另一个方法从channel中拿数据，并且进行操作，最后打印

package main

import (
    "fmt"
    "sync"
)

var wg sync.WaitGroup
//创建非缓冲通道
var cha = make(chan int)

func getNum(num int){
    defer wg.Done()
    cha <- num
}

func operationNum(){
    defer wg.Done()
    num := <- cha
    num = num * 10
    fmt.Println("拿到的值是：",num)
}

func main() {
    wg.Add(2)
    go getNum(10)
    go operationNum()
    wg.Wait()
    fmt.Println("主函数执行完成！")
}

4. 单向channel
   存在的意义：有些时候为了接口的安全，有些接口中只能接收通道的值和只能规定通道返回值，所以必须得有单向channel
   只能存值的channel：
   只能取值的channel:

    package main
    
    import (
        "fmt"
        "sync"
    )
    
    var wg sync.WaitGroup
    var cha = make(chan int)
    
    func getNum(num int)<-chan int{
        defer wg.Done()
        cha <- num
        return cha
    }
    
    func operationNum(){
        defer wg.Done()
        num := <- cha
        num = num * 10
        fmt.Println("拿到的值是：",num)
    }
    
    func getChan(in chan<-int ){
        defer wg.Done()
        fmt.Println("接收到一个channel")
    }
    
    func main() {
        wg.Add(2)
        go getNum(10)
        go operationNum()
        var cha1 = make(chan<- int)
        go getChan(cha1)
        wg.Wait()
        fmt.Println("主函数执行完成！")
    }