func GetGID() uint64 {
    b := make([]byte, 64)
    b = b[:runtime.Stack(b, false)]
    b = bytes.TrimPrefix(b, []byte("goroutine "))
    b = b[:bytes.IndexByte(b, ' ')]
    n, _ := strconv.ParseUint(string(b), 10, 64)
    return n
}

import (
  "fmt"
  "runtime"
  "sync"
)
var (
  count int32
  wg  sync.WaitGroup
)
func main() {
  wg.Add(2)
  go incCount()
  go incCount()
  wg.Wait()
  fmt.Println(count)
}
func incCount() {
  defer wg.Done()
  for i := 0; i < 2; i++ {
    value := count
    runtime.Gosched()
    value++
    count = value
  }
}

==================
WARNING: DATA RACE
Read at 0x000000619cbc by goroutine 8:
 main.incCount()
   D:/code/src/main.go:25 +0x80// goroutine 8 在代碼 25 行讀取共享資源value := count
Previous write at 0x000000619cbc by goroutine 7:
 main.incCount()
   D:/code/src/main.go:28 +0x9f// goroutine 7 在代碼 28行修改共享資源count=value
Goroutine 8 (running) created at:
 main.main()
   D:/code/src/main.go:17 +0x7e
Goroutine 7 (finished) created at:
 main.main()
   D:/code/src/main.go:16 +0x66//兩個 goroutine 都是從 main 函數(shù)的 16、17 行通過 go 關(guān)鍵字啟動的。
==================
4
Found 1 data race(s)

import (
  "fmt"
  "runtime"
  "sync"
  "sync/atomic"
)
var (
  counter int64
  wg   sync.WaitGroup
)
func main() {
  wg.Add(2)
  go incCounter(1)
  go incCounter(2)
  wg.Wait() //等待goroutine結(jié)束
  fmt.Println(counter)
}
func incCounter(id int) {
  defer wg.Done()
  for count := 0; count < 2; count++ {
    atomic.AddInt64(&counter, 1) //安全的對counter加1
    runtime.Gosched()
  }
}

import (
  "fmt"
  "sync"
  "sync/atomic"
  "time"
)
var (
  shutdown int64
  wg    sync.WaitGroup
)
func main() {
  wg.Add(2)
  go doWork("A")
  go doWork("B")
  time.Sleep(1 * time.Second)
  fmt.Println("Shutdown Now")
  atomic.StoreInt64(&shutdown, 1)
  wg.Wait()
}
func doWork(name string) {
  defer wg.Done()
  for {
    fmt.Printf("Doing %s Work\n", name)
    time.Sleep(250 * time.Millisecond)
    if atomic.LoadInt64(&shutdown) == 1 {
      fmt.Printf("Shutting %s Down\n", name)
      break
    }
  }
}
--output--
Doing A Work
Doing B Work
Doing B Work
Doing A Work
Doing A Work
Doing B Work
Doing B Work
Doing A Work//前8行順序每次運行時都不一樣
Shutdown Now
Shutting A Down
Shutting B Down//A和B都shut down后，由wg.Done()把計數(shù)器置0

func incCounter(id int) {
  defer wg.Done()
  for count := 0; count < 2; count++ {
    //同一時刻只允許一個goroutine進(jìn)入這個臨界區(qū)
    mutex.Lock()
    {
      value := counter
      runtime.Gosched()//退出當(dāng)前goroutine，調(diào)度器會再次分配這個 goroutine 繼續(xù)運行。
      value++
      counter = value
    }
    mutex.Unlock() //釋放鎖，允許其他正在等待的goroutine進(jìn)入臨界區(qū)
  }
}

import (
  "fmt"
  "time"
)
func main() {
  // 構(gòu)建一個通道，這里有沒有緩沖都可，因為是收了就發(fā)，無需阻塞等待
  ch := make(chan int)
  // 開啟一個并發(fā)匿名函數(shù)
  go func() {
    // 從3循環(huán)到0
    for i := 3; i >= 0; i-- {
      // 發(fā)送3到0之間的數(shù)值
      ch <- i
      // 每次發(fā)送完時等待
      time.Sleep(time.Second)
    }
  }()
  // 遍歷接收通道數(shù)據(jù)
  for data := range ch {
    // 打印通道數(shù)據(jù)
    fmt.Println(data)
    // 當(dāng)遇到數(shù)據(jù)0時, 退出接收循環(huán)
    if data == 0 {
        break
    }
  }
}
--output--

ch := make(chan int)
// 聲明一個只能寫入數(shù)據(jù)的通道類型, 并賦值為ch
var chSendOnly chan<- int = ch
或
ch := make(chan<- int)
//聲明一個只能讀取數(shù)據(jù)的通道類型, 并賦值為ch
var chRecvOnly <-chan int = ch
或
ch := make(<-chan int)

// 這個示例程序展示如何用無緩沖的通道來模擬
// 2 個goroutine 間的網(wǎng)球比賽
package main
import (
  "fmt"
  "math/rand"
  "sync"
  "time"
)
// wg 用來等待程序結(jié)束
var wg sync.WaitGroup
func init() {
  rand.Seed(time.Now().UnixNano())
}
// main 是所有Go 程序的入口
func main() {
  // 創(chuàng)建一個無緩沖的通道
  court := make(chan int)
  // 計數(shù)加 2，表示要等待兩個goroutine
  wg.Add(2)
  // 啟動兩個選手
  go player("Nadal", court)
  go player("Djokovic", court)
  // 發(fā)球
  court <- 1
  // 等待游戲結(jié)束
  wg.Wait()
}
// player 模擬一個選手在打網(wǎng)球
func player(name string, court chan int) {
  // 在函數(shù)退出時調(diào)用Done 來通知main 函數(shù)工作已經(jīng)完成
  defer wg.Done()
  for {
    // 等待球被擊打過來
    ball, ok := <-court
    if !ok {
      // 如果通道被關(guān)閉，我們就贏了
      fmt.Printf("Player %s Won\n", name)
      return
    }
    // 選隨機(jī)數(shù)，然后用這個數(shù)來判斷我們是否丟球
    n := rand.Intn(100)
    if n%13 == 0 {
      fmt.Printf("Player %s Missed\n", name)
      // 關(guān)閉通道，表示我們輸了
      close(court)
      return
    }
    // 顯示擊球數(shù)，并將擊球數(shù)加1
    fmt.Printf("Player %s Hit %d\n", name, ball)
    ball++
    // 將球打向?qū)κ?，為啥這里是把ball發(fā)送到另一個go協(xié)程？
    //因為court無緩沖，此時另一個go協(xié)程正好在等待接收court內(nèi)的值，所以此時轉(zhuǎn)向另一個go協(xié)程代碼
    court <- ball
  }
}

select {
  case <-chan1:
  // 如果chan1成功讀到數(shù)據(jù)，則進(jìn)行該case處理語句
  case chan2 <- 1:
  // 如果成功向chan2寫入數(shù)據(jù)，則進(jìn)行該case處理語句
  default:
  // 如果上面都沒有成功，則進(jìn)入default處理流程
}

func main() {
  ch := make(chan int)
  quit := make(chan bool)
  //新開一個協(xié)程
  go func() {
    for {
      select {
      case num := <-ch:
        fmt.Println("num = ", num)
      case <-time.After(3 * time.Second):
        fmt.Println("超時")
        quit <- true
      }
    }
  }() //別忘了()
  for i := 0; i < 5; i++ {
    ch <- i
    time.Sleep(time.Second)//主協(xié)程進(jìn)入休眠狀態(tài)，等待上面的go協(xié)程運行并進(jìn)入阻塞等待狀態(tài)，就這樣來回運行，并通過chan通信
  }
  <-quit
  fmt.Println("程序結(jié)束")
}
--output--
num = 0
num = 1
num = 2
num = 3
num = 4
超時
程序結(jié)束