func test() {
   fmt.Println("go go go")
}

func main() {
   fmt.Println("主線程開始")
    
   // go 關鍵字開啟 Goroutine，一個 Goroutine只占2kb左右
   go test() // 一個 go 就是一個協(xié)程，多個就是多個協(xié)程，也可以for循環(huán)起多個協(xié)程
   go test()
    
   time.Sleep(1*time.Second)  // Go 語言中主線程不會等待Goroutine執(zhí)行完成，要等待它結(jié)束需要自己處理
   fmt.Println("主線程結(jié)束")
}

// 輸出：
主線程開始
go go go
go go go
主線程結(jié)束

func main() {
   // 1、定義 channel
   var c chan int

   // 2、管道的零值
   //———>空值為 nil 說明是引用類型，當做參數(shù)傳遞時，不需要取地址，改的就是原來的，需要初始化在使用
   fmt.Println(c)     // 輸出：<nil>

   // 3、管道初始化
   c = make(chan int)
   go test(c)        // c 是引用類型直接傳

   // 4、從信道中取值，信道默認不管放值還是取值，都是阻塞的
   count := <-c   // 阻塞
   fmt.Println(count)
   
   /*
   當程序執(zhí)行 go test(c) 時就開了一個 Goroutine
   然后繼續(xù)執(zhí)行到 count := <-c 從信道取值，這時就阻塞住了
   它會等待 Goroutine 往信道中放值后才會取出值，才會繼續(xù)執(zhí)行 fmt.Println(count)
   */
}

func test(c chan int) {
   fmt.Println("GO GO GO")
   time.Sleep(1 * time.Second)
   // 5、往信道中放一個值，信道默認不管放值還是取值，都是阻塞的
   c <- 1 // 阻塞
}

// 輸出：
<nil>
GO GO GO
1

func main() {  
    c := make(chan int)
    c <- 1
}

// 報錯：應為沒有其他 Goroutine 從 c 中取值

func WriteOnly(c chan<- int) {
   c <- 1
}

func main() {
   write := make(chan<- int)  // 只寫信道
   go WriteOnly(write)
   fmt.Println(<-write)      // 報錯   ——>只寫信道往外取就報錯
}

func WriteOnly(c chan<- int) {
   c <- 1
   // <-c       // 報錯
}

func main() {
   write := make(chan int)    // 定義一個可讀可寫信道
   go WriteOnly(write)        // 傳到函數(shù)中就成了只寫信道，在Goroutine中只負責寫，不能往外讀
   fmt.Println(<-write)     // 主協(xié)程讀
}

func producer(chnl chan int) {
   for i := 0; i < 10; i++ {
      chnl <- i   // i 放入信道
   }
   close(chnl)      // 關閉信道
}

func main() {
   ch := make(chan int)
   go producer(ch)
   // 循環(huán)獲取信道內(nèi)容
   for value := range ch {
      fmt.Println(value)
   }
}

/*
當 for 循環(huán) range ch 的時候信道沒有值，會阻塞等待 go producer(ch) 開起的 Goroutine 中放入值
當 Goroutine 中放入一個值，就會阻塞，那么 range ch 就會取出一個值，然后再次阻塞等待
直到 Goroutine 放入值完畢關閉信道，for 循環(huán) range ch 也就結(jié)束循環(huán)了
*/

func main() {
   // 指定的數(shù)字就是緩沖大小
   var c chan int = make(chan int, 3) // 無緩沖信道數(shù)字是0
   c <- 1
   c <- 2
   c <- 3
   c <- 4     // 緩沖滿了，死鎖

   <-c
   <-c
   <-c
   <-c          // 取空了，死鎖

   fmt.Println(len(c))       // 長度：目前放了多少
   fmt.Println(cap(c))       // 容量：可以最多放多少
}

func process1(i int, wg *sync.WaitGroup) {
   fmt.Println("started Goroutine ", i)
   time.Sleep(2 * time.Second)
   fmt.Printf("Goroutine %d ended\n", i)
   // 3、一旦有一個完成，減一
   wg.Done()
}

func main() {
   var wg sync.WaitGroup    // 沒有初始化，值類型，當做參數(shù)傳遞，需要取地址

   for i := 0; i < 10; i++ {
      wg.Add(1)      // 1、啟動一個 Goroutine，add 加 1
      go process1(i, &wg)     // 2、把wg傳過去，因為要改它并且它是值類型需要取地址傳過去
   }

   wg.Wait()  // 4、一直阻塞在這，直到調(diào)用了10個 Done，計數(shù)器減到零
}

// 模擬去服務器去取值
func server(ch chan string) {
   time.Sleep(3 * time.Second)
   ch <- "from server"
}

func main() {
   output1 := make(chan string)
   output2 := make(chan string)
    
   // 開起兩個協(xié)程執(zhí)行 server
   go server(output1)
   go server(output2)

   select {
   case s1 := <-output1:  // 阻塞，誰先回來就執(zhí)行誰
      fmt.Println(s1, "output1")
   case s2 := <-output2:  // 阻塞，誰先回來就執(zhí)行誰
      fmt.Println(s2, "output2")
   }
}

var x = 0   //全局，各個 Goroutine 都可以拿到并且操作

func increment(wg *sync.WaitGroup) {
   x = x + 1
   wg.Done()
}

func main() {
   var w sync.WaitGroup
   for i := 0; i < 1000; i++ {
      w.Add(1)
      go increment(&w)
   }
   w.Wait()

   fmt.Println("最終的值：", x)
}

// 輸出：理想情況下是1000，因為并發(fā)有安全的問題，所以數(shù)據(jù)亂了
最終的值： 978

var x = 0   //全局，各個 Goroutine 都可以拿到并且操作

func increment(wg *sync.WaitGroup, m *sync.Mutex) {
   m.Lock()    // 加鎖
   x = x + 1 // 同一時間只能有一個 Goroutine 執(zhí)行
   m.Unlock()  // 解鎖
   wg.Done()
}
func main() {
   var w sync.WaitGroup
   var m sync.Mutex    // 因為是個值類型，函數(shù)傳遞需要傳地址
   fmt.Println(m)     // 輸出：{0 0} ——>值類型

   for i := 0; i < 1000; i++ {
      w.Add(1)
      go increment(&w, &m)
   }
   w.Wait()
   fmt.Println("最終的值：", x)
}

// 輸出：
最終的值： 1000

var x = 0

func increment(wg *sync.WaitGroup, ch chan bool) {
   ch <- true   // 緩沖信道放滿了，就會阻塞。
   x = x + 1
   <-ch         // 執(zhí)行完了就取出
   wg.Done()
}
func main() {
   var w sync.WaitGroup
   ch := make(chan bool, 1)   // 定義了一個有緩存大小為1的信道
   for i := 0; i < 1000; i++ {
      w.Add(1)
      go increment(&w, ch)
   }

   w.Wait()
   fmt.Println("最終的值：", x)
}

// 輸出：
最終的值：1000

func main() {
 defer fmt.Println("我最后執(zhí)行")
 defer fmt.Println("我倒數(shù)第三執(zhí)行")
 fmt.Println("我先執(zhí)行")
    
 var a []int
 fmt.Println(a[10])   // 報錯

 fmt.Println("后執(zhí)行") // 不會執(zhí)行了
}


// 輸出：
我先執(zhí)行
我倒數(shù)第三執(zhí)行
我最后執(zhí)行
panic: runtime error: index out of range [10] with length 0
panic：主動拋出異常

recover：恢復程序，繼續(xù)執(zhí)行

func f1() {
   fmt.Println("f1 f1")
}


func f2() {
   defer func() {        // 這個匿名函數(shù)永遠會執(zhí)行

      //如果沒有錯誤，執(zhí)行 recover 會返回 nil，如果有錯誤執(zhí)行 recover 會返回錯誤信息
      if error := recover(); error != nil {
         // 表示出錯了，打印一下錯誤信息，程序恢復了，繼續(xù)執(zhí)行
         fmt.Println(error)
      }
      fmt.Println("我永遠會執(zhí)行，不管是否出錯")
   }()
    
   fmt.Println("f2 f2")
   panic("主動拋出錯誤")
}


func f3() {
   fmt.Println("f3 f3")
}


func main() {
   //捕獲異常，處理異常，讓程序繼續(xù)運行
   f1()
   f2()
   f3()
}

try:
 可能會錯誤的代碼
except Exception as e：
 print(e)
finally：
 無論是否出錯，都會執(zhí)行的代碼

defer func() {
 if error:=recover();error!=nil{
  // 錯誤信息 error
  fmt.Println(error)
 }
    
 相當于finally，無論是否出錯，都會執(zhí)行的代碼
    
}()

可能會錯誤的代碼