package main

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

var wg sync.WaitGroup

func hello(m string) {
 if m == "waitgroup" {
        // 让 WaitGroup 计数器 -1
  defer wg.Done()
 }

 i := 0
 for {
  fmt.Printf("Hello world goroutine,%v\n", i)
  i += 1
  if i == 3 {
   return
  }
 }
}

func timeSleepGotourine() {
 // 调用了 go hello() 之后，程序控制没有等待 hello 协程结束，
 // 立即返回到了代码下一行，打印 main function。
 // 接着由于没有其他可执行的代码，Go 主协程终止，
 // 于是 hello 协程就没有机会运行了。
 go hello("timesleep")

 // 调用了 time 包里的函数 Sleep，该函数会休眠执行它的 Go 协程。
 // 在这里，我们使 Go 主协程休眠了 1 秒。因此在主协程终止之前，
 // 调用 go hello() 就有足够的时间来执行了。
 // 该程序首先打印 Hello world goroutine，等待 1 秒钟之后，接着打印 main function。
 time.Sleep(1 * time.Second)
 // 也可以使用下面的方式让程序在手动按回车才结束。
 // fmt.Scanln()
 fmt.Println("main function")
}

func waitGroupGotoutine() {
    // 为 WaitGroup 计数器 +1
 wg.Add(1)

 go hello("waitgroup")

 // 等待 WaitGroup 计数器归零，归零后，wg.Wait() 释放，并继续执行后面的代码、
 wg.Wait()

 fmt.Println("main function")
}

func main() {
 // 通过睡眠，让 main() 等待协程完成
 timeSleepGotourine()
 // 通过 WaitGroup，让 main() 等待协程完成
 waitGroupGotoutine()
}

package main

import (
 "fmt"
)

func correct() {
 // 使用make函数创建一个新的通道。通道类型就是他们需要传递值的类型
 messages := make(chan string)

 // 使用`ChannelID <-`语法发送(send)一个新的值到通道中
 go func() { messages <- "ping" }()

 // 使用`<- ChannelID`语法从通道中接收(receives)一个值
 msg := <-messages
 fmt.Println(msg)
}

func error() {
 messages := make(chan string)

 // 如果不使用协程，则运行程序时，会报“死锁”的错,错误信息如下：
 // fatal error: all goroutines are asleep - deadlock!
 // 因为，代码是一行一行执行的，如果一个没有缓存的通道在接收数据之后，需要同步把数据发送给接收者。
 // 可是当前行的代码还没执行完，怎么能执行后面的呢，没有后面的代码，也就没有接收者，所以这就是错误产生的原因。
 // 当通道使用协程的方式运行时，就算当前时刻没有接收者，这个通过协程运行起来的通道，一会自动阻塞，并等待接收者。否则不通过协程启动通道，那么就跟普通代码一样。
 func() { messages <- "ping" }()

 // 可以使用如下方式直接输出通道内的数据，相当于fmt.Println就是通道的接收者
 fmt.Println(-messages)
}

func buffer() {
 messages := make(chan string, 1)

 // 带缓冲的通道可以不使用协程。
 messages <- "ping"

 fmt.Println(-messages)
}

func main() {
 fmt.Println("1.通道正确的示例")
 // correct()
 fmt.Println("2.通道会导致死锁的示例")
 // error()
 fmt.Println("3.通道缓冲")
 buffer()

}

// 默认发送和接收操作是阻塞的，直到发送方和接收方都准备完毕。
// 这个特性允许我们，不使用任何其它的同步操作，来在程序结尾等待消息"ping"

package main

import (
 "fmt"
 "sync"
 // "time"
)

func sendData(ch chan string, done chan bool, wg sync.WaitGroup) {
 // 该函数把几个字符串发送给通道ch，使得这些字符串会存在一个管道中，等待输出
 ch <- "Tianjin"
 ch <- "Beijing"
 ch <- "China"

 // 当完成数据发送时，发送通知
 done <- true

 // 让 WaitGroup 计数器 -1
 wg.Done()
}

func recvData(ch chan string, done chan bool, wg sync.WaitGroup) {
I:
 for {
  select {
  // 把通道中的字符串都赋值给变量input
  case input := <-ch:
   fmt.Println(input)

  // 当通道通知完成数据传输时，跳出循环
  case <-done:
   break I
  }
 }

 // 让 WaitGroup 计数器 -1
 wg.Done()
}

func main() {
 // 声明 WaitGroup 计数器
 // WaitGroup 等待一组 goroutine 完成。主 goroutine 调用 Add 来设置要等待的 goroutine 的数量。
 // 然后每个 goroutine 运行并在完成时调用 Done。 同时，Wait 可用于阻塞，直到所有 goroutine 完成。
 var wg sync.WaitGroup
 // 为 WaitGroup 计数器 +2，当计数器减为 0 时，wg.Wait() 将会释放，并继续执行后面的代码。
 wg.Add(2)
 // ch通道用来传递数据；done通道用来传递任务是否完成的消息。
 ch := make(chan string)
 done := make(chan bool)

 // 把通道ch作为参数传递给两个协程函数
 // 可以理解为把通道的两端分别连接到两个协程函数上
 go sendData(ch, done, wg)
 go recvData(ch, done, wg)

 // 通过 wg.Wait() 让 main() 等待协程完成。
 // 如果不让 main() 等待，则无任何输出，或者报错 panic: send on closed channel。因为协程是并发运行，不用等代码运行完成就会执行后续代码。
 // 如果后续代码执行完了，协程中的代码还没执行完成，就会没有任何输出。
 // 如果后续代码中包含了关闭通道的操作，那么程序将会 panic，并报错 send on closed channel
 wg.Wait()
}