深入浅出Go并发之协程—goroutine

package main
func main() {
   go func() {
      println("Hello goruntine")
   }()
}

package main
import "time"
func main() {
   go func() {
      println("Hello goruntine")
   }()
   time.Sleep(3 * time.Second)
}

package main
import (
   "fmt"
   "sync"
   "time"
)
func main() {
   var wg sync.WaitGroup
   fmt.Println("This is main thread start ...")
   wg.Add(2)
   go func() {
      defer wg.Done()
      fmt.Println("Go 1 finished ...")
   }()
   go func() {
      defer wg.Done()
      time.Sleep(3 * time.Second)
      fmt.Println("Go 2 finished ...")
   }()
   wg.Wait()
   fmt.Println("This is main thread finished ...")
}

package main
import (
   "fmt"
   "sync"
)
func main() {
   var locker = new(sync.Mutex)
   var cond = sync.NewCond(locker)
   var done bool = false
   fmt.Println("Main is start...")
   cond.L.Lock()
   go func() {
      fmt.Println("Go is finished... ")
      done = true
      cond.Signal()
   }()
   fmt.Println("Main is wait...")
   if !done {
      cond.Wait()
      cond.L.Unlock()
   }
   fmt.Println("Main is finished...")
}

//Stack描述了一个Go执行堆栈。堆栈的边界是[lo, hi)，两边都没有隐式数据结构。  
type stack struct {
   lo uintptr //下界
   hi uintptr //上界
}
type g struct {
   // Stack信息.
   stack       stack   // offset known to runtime/cgo
   stackguard0 uintptr // offset known to liblink
   stackguard1 uintptr // offset known to liblink
   _panic       *_panic // innermost panic - offset known to liblink
   _defer       *_defer // innermost defer
   m            *m      // current m; offset known to arm liblink
   sched        gobuf   // goroutine切换时，用于保存g的上下文
   ......
}

const (
   // G status
   _Gidle = iota //空闲中。G刚刚新建, 仍未初始化
    
   _Grunnable //待运行。就绪状态，G在运行队列中, 等待M取出并运行
    
   _Grunning //运行中。M正在运行这个G, 这时候M会拥有一个P
    
   _Gsyscall //系统调用中。M正在运行这个G发起的系统调用, 这时候M并不拥有P
    
   _Gwaiting // 等待中。G在等待某些条件完成, 这时候G不在运行也不在运行队列中(可能在channel的等待队列中)
    
   _Gmoribund_unused // 当前未使用。但在gdb中硬编码脚本。  
    
   _Gdead // 已中止。G未被使用, 可能已执行完毕
    
   _Genqueue_unused //  当前未使用。
    
   _Gcopystack // 栈复制中。G正在获取一个新的栈空间并把原来的内容复制过去(用于防止GC扫描)
    
   _Gpreempted // 停止自己来暂停抢占。 它类似于_Gwaiting，并且不在运行队列上，等待唤醒。
    
   // 以下状态为GC相关
   _Gscan          = 0x1000
   _Gscanrunnable  = _Gscan + _Grunnable  // 0x1001
   _Gscanrunning   = _Gscan + _Grunning   // 0x1002
   _Gscansyscall   = _Gscan + _Gsyscall   // 0x1003
   _Gscanwaiting   = _Gscan + _Gwaiting   // 0x1004
   _Gscanpreempted = _Gscan + _Gpreempted // 0x1009
)

type g struct {
   stack       stack   // offset known to runtime/cgo
   stackguard0 uintptr // offset known to liblink
   stackguard1 uintptr // offset known to liblink
   _panic       *_panic // innermost panic - offset known to liblink
   _defer       *_defer // innermost defer
   m            *m      // current m; offset known to arm liblink
   sched        gobuf
   ......
}

type m struct {
   g0      *g     // goroutine with scheduling stack
   morebuf gobuf  // gobuf arg to morestack
   divmod  uint32 // div/mod denominator for arm - known to liblink
   procid        uint64       // for debuggers, but offset not hard-coded
   gsignal       *g           // signal-handling g
   goSigStack    gsignalStack // Go-allocated signal handling stack
   sigmask       sigset       // storage for saved signal mask
   tls           [6]uintptr   // thread-local storage (for x86 extern register)
   mstartfn      func()
   curg          *g       // current running goroutine
   caughtsig     guintptr // goroutine running during fatal signal
   p             puintptr // attached p for executing go code (nil if not executing go code)
   nextp         puintptr
   oldp          puintptr // the p that was attached before executing a syscall
   id            int64
   mallocing     int32
   throwing      int32
   preemptoff    string // if != "", keep curg running on this m
   ......
}

type p struct {
   id          int32
   status      uint32 // one of pidle/prunning/...
   link        puintptr
   schedtick   uint32     // incremented on every scheduler call
   syscalltick uint32     // incremented on every system call
   sysmontick  sysmontick // last tick observed by sysmon
   m           muintptr   // back-link to associated m (nil if idle)
   mcache      *mcache
   pcache      pageCache
   raceprocctx uintptr
   deferpool    [5][]*_defer // pool of available defer structs of different sizes (see panic.go)
   deferpoolbuf [5][32]*_defer
   // Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.
   goidcache    uint64
   goidcacheend uint64
   // Queue of runnable goroutines. Accessed without lock.
   runqhead uint32
   runqtail uint32
   runq     [256]guintptr
 
   ......
}

type schedt struct {
   // accessed atomically. keep at top to ensure alignment on 32-bit systems.
   goidgen   uint64
   lastpoll  uint64 // time of last network poll, 0 if currently polling
   pollUntil uint64 // time to which current poll is sleeping
   lock mutex
   midle        muintptr // idle m's waiting for work
   nmidle       int32    // number of idle m's waiting for work
   nmidlelocked int32    // number of locked m's waiting for work
   mnext        int64    // number of m's that have been created and next M ID
   maxmcount    int32    // maximum number of m's allowed (or die)
   nmsys        int32    // number of system m's not counted for deadlock
   nmfreed      int64    // cumulative number of freed m's
   ngsys uint32 // number of system goroutines; updated atomically
   ...
}