并行和并发

并行： 指在同一时刻，有多条指令在多个处理器上同时进行
并发：同一时刻只能有一条指令执行，但是多个指令被快速的轮换执行，在宏观上体现出过个进程同时执行的效果，微观上是把时间分成若干段，使得多个进程快速交替执行

goroutine（协程）--- 并发核心

执行goroutine只要极少的栈内存（4-5kb），自动伸缩，goroutine比thread更易用、高效、轻便

// 创建一个goroutine ： 只要在函数调用语句前添加go 关键字，就可以创建并发执行单元--协程
func add(){
  for{
    fmt.Println("bbbb")
  }
}
func main(){
  go add()
  for{
    fmt.Println("xxxx")
  }
  // 打一部分 xxx 打一部分 bbb
}

主协程退出，其余子协程都将被关闭--有可能主协程退出太快，导致其他子协程没调用就退出

runtime包

// runtime.Gosched 短暂让出cpu的时间片，让其他协程执行，不定时后再回到此协程
func main() {

    for i := 0; i < 10; i++ {
        go showNumber(i)
    }
    runtime.Gosched()
    fmt.Println("Haha")
    // 1,0,9, haha
    // 1,2,3,6,haha  每次运行有不同结果
    // runtime.Gosched()是短暂让出cpu的时间片，让其他协程执行，不定时后再回到此协程
}
func showNumber (i int) {
    fmt.Println(i)
}

// runtime.Goexit()   // 退出此协程，return 是退出此函数

// runtime.GOMAXPROCS()  指定以多少核运算，不写默认单核。runtime.GOMAXPROCS(2) 指定2核cpu运算  

多任务资源竞争：

func main() {
  go printer("hello")
  go printer("world")
  for{}
}
func printer (str string) {
  for _,v:= range str{
     fmt.Printf("%c",v)
     time.Sleep(time.Second)
  }
  fmt.Print("\n")   //  hwoelrllod 打印出来这样，每个协程用一会儿就换另外个
}

// 为了解决多任务资源竞争的问题，需要channel实现

channel数据类型（引用类型），可以用make（）创建(用于多个goruntine通讯，内部实现了同步，确保并发安全)

创建一个channel，
make(chan Type)  === make(chan Type, 0 ) 无缓冲的channel 读写阻塞
make(chan Type, cap)  有缓存的channel 无阻塞，满了或者空的才阻塞

channel 数据操作
channel<-  value  // 发送数据到管道
<-channel    //管道取出数据丢弃，
x:= <-channel   // 取出数据赋值给x
x，ok := <-channel  // 功能同上，同时检测通道是否已经关闭或者是否为空

默认情况下，channel收发数据都是阻塞的，除非另一端准备好，同时接收，这就让gorountine同步变得更加简单，不需要显示的lock
var chans = make(chan int) // 创建一个通道channel
func main(){
   go pers("hello")   // 开启新协程
   go pers1("world")  // 开启新协程
   for{}  // 防止主协程退出 
   // world    hello
}
func pers(str string){
  <-chans   // 通道取值，没有则阻塞此通道运行
  Printer(str)
}
func pers1(str string){
  Printer(str)  
  chans <- 666  // 通道传递值。
}
func Printer(str string){
   for _, v := range str{
     fmt.Printf("%c",v)
   }
   fmt.Print("\n")
}

channel 实现同步和数据交互

func main(){
  var cha = make(chan string)
  go func (){
    for i:=0;i<2; i++{
      fmt.Println(i)
    }
    cha<- "oks"
    fmt.Println("子协程结束")
  }()
  str := <- cha
  fmt.Println(str,"主协程结束")
}

无缓冲channel

func main(){
  var cha = make(chan int) //创建无缓冲channel
  go func (){
    for i:=0;i<2; i++{
      cha <- i
      fmt.Println("子协程",i)
    }
    fmt.Println("子协程结束")
  }()
  time.Sleep(time.Second)
  for i:=0;i<2; i++{
    str := <-cha
    fmt.Println("主协程",str)
  }
  fmt.Println("主协程结束")
  /*
  主协程 0
  子协程 0
  子协程 1
  子协程结束
  主协程 1
  主协程结束
   */
}

有缓冲channel

func main(){
  var cha = make(chan int,3) //创建有缓冲channel
  go func (){
    for i:=0;i<5; i++{
      cha <- i
      fmt.Println("子协程",i)
    }
    fmt.Println("子协程结束")
  }()
  time.Sleep(time.Second)
  for i:=0;i<5; i++{
    str := <-cha
    fmt.Println("主协程",str)
  }
  fmt.Println("主协程结束")
  /*
  子协程 0
  子协程 1
  子协程 2  // 一次性存三个，然后等一秒
  主协程 0
  主协程 1
  主协程 2  // 一次性取三个。后面的就不确定了
  主协程 3
  子协程 3
  子协程 4
  子协程结束
  主协程 4
  主协程结束
   */
}

关闭channel

func main(){
  var cha = make(chan int)
  go func (){
     for i:=0 ;i <4; i++{
       cha<- i
     }
     close(cha)  // 关闭channel,能继续读数据，不能存数据
  }()
  time.Sleep(time.Second)
  for num:=range ch{
      fmt.Println("num=",num)
  }  // 遍历channel，关闭后自动退出遍历
  for{
     if v,oks := <-cha; oks ==true{ //v为值，oks为cha是否关闭，关闭为false
        fmt.Println("主协程",v)
     }else{break}
  }
}

单向channel特点和应用

var cha1 chan int   // 正常channel，双向
var cha2 chan<-  float64  // 单项，只能写入
var  cha3  <-chan  int   // 单项，只能读取int数据
双向可以隐式转换为单项channel,反之不能

ch :=make(chan int)  //双向
var  wirteCh chan<-  int = ch // 只能写，不能读
var  readCh <-chan  int = ch // 只能读，不能写
eg:
func Productor(out chan<- int){ // 参数必须为输入channel
   for i:=0 ;i<10; i++ {
     out<- i*i // 写入
   }
   close(out) // 关闭channel
}
func customer(in <-chan int){ // 参数必须为输出channel
   for v := range in{  // 当channel关闭后会自动退出循环
     fmt.Print(v," ")
   }
}
func main(){
   ch := make(chan int)
   go Productor(ch)
   customer(ch)
   /*  0 1 4 9 16 25 36 49 64 81  */
}

定时器Timer 和Ticker

Timer:一次性定时器

// Timer实现延时功能
func main(){
   timer := time.NewTimer(time.Second*4) //创建一个timer，多少秒后会注入到timer的channel里面
   <-timer.C   // 一开始为空值，阻塞程序运行，取到值后继续执行下面
   fmt.Print(timer)
}

// time.Sleep( time.Second *n) 也能延时 n秒

// <- time.After( 2 * time.Second)  // 定时2s,2s后往channel写内容,返回的是一个管道

// 停止定时器 timer.Stop()
timer := time.NewTimer(3 * time.Second)
go  func(){
    <-timer.C
    fmt.Print("xxx")
}
timer.Stop() //停止定时器  导致xxx不能打印

// 重置定时器
timer := time.NewTimer(3* time.Second)
timer.Reset(1 * time.Second)  // 重新设置为1s， 返回值为bool
<-timer.C  //去channel的值

Ticker:周期往channel发送一个事件，而channel接收者可以固定时间间隔从channel里面取

 ticker := time.NewTicker(time.Second*2)
   i :=0
   for{
      i++
      <-ticker.C
      fmt.Println(i)
      if i ==5{
        ticker.Stop()
        break
      }
   }

select 监测channel上的数据流动

每个case语句里必须是一个IO操作,在一个select语句中，Go语言会按顺序从头至尾评估每一个发送和接收的语句,如果其中的任意一语句可以继续执行(即没有被阻塞)，那么就从那些可以执行的语句中任意选择一条来使用。
如果没有任意一条语句可以执行(即所有的通道都被阻塞)，那么有两种可能的情况：
如果给出了default语句，那么就会执行default语句，同时程序的执行会从select语句后的语句中恢复。
如果没有default语句，那么select语句将被阻塞，直到至少有一个通信可以进行下去。

func main(){
  // 超时打印
  ch :=make(chan int)
  quit :=make(chan bool)
  go func (){
    for{
      select{
      case num := <-ch:
         fmt.Println(num)
      case <-time.After(5*time.Second): //5秒后添加事件到time的channel事件
         quit <- true  
         fmt.Print("超时quit\n")
      }
    }
  }()
  <-quit
  fmt.Println("主协程退出")
}

select 实现斐波拉切数列

func main() {
    // select 实现斐波拉切数列
    ch := make(chan int)    // 数据传递通道
    quit := make(chan bool) // 退出通道

    // 使用者
    go func() {
        for i := 0; i < 8; i++ {
            num := <-ch
            fmt.Println(num)
        }
        quit <- true
    }()
    //生产者
    feibo(ch, quit)
}
func feibo(ch chan<- int, quit <-chan bool) {
    x, y := 1, 1
    for {
        select {
        case ch <- x:
            x, y = y, x+y
        case <-quit:
            fmt.Print("oks")
            return
        }
    }
}