进程，线程，协程

进程：为了占据内存空间

  1. 操作系统 “程序” 最新小单位
  2. 进程用来占用空间
  3. 如果计算机是一个工厂，进程相当于厂房，占用工厂空间

image.png

线程：占用工厂(CPU)处理能力

  1. 每个进程可以有多个线程
  2. 线程使用系统分配给进程的内存，线程之间共享内存

image.png

线程原理

  1. 线程用来占用CPU时间
  2. 线程的调度需要由系统进行，开销较大
  3. 线程相当于工厂的生产线，占用工人的工时

  4. 线程里跑的程序就是生产流程

    线程的问题

  5. 线程本身占用资源大

  6. 线程的操作开销大
  7. 线程切换开销大

    协程

image.png
image.png

总结

  1. 进程用徕分配内存空间
  2. 线程用来分配CPU时间
  3. 协程用来切换不同的线程

  4. 协程的本质是一段包含运行状态的程序

    协程的本质

    协程底层结构

    1. type g struct {
    2.  // Stack parameters.
    3.  // stack describes the actual stack memory: [stack.lo, stack.hi).
    4.  // stackguard0 is the stack pointer compared in the Go stack growth prologue.
    5.  // It is stack.lo+StackGuard normally, but can be StackPreempt to trigger a preemption.
    6.  // stackguard1 is the stack pointer compared in the C stack growth prologue.
    7.  // It is stack.lo+StackGuard on g0 and gsignal stacks.
    8.  // It is ~0 on other goroutine stacks, to trigger a call to morestackc (and crash).
    9.  stack       stack   // offset known to runtime/cgo 协程栈
    10.  stackguard0 uintptr // offset known to liblink
    11.  stackguard1 uintptr // offset known to liblink
    13.  _panic       *_panic // innermost panic - offset known to liblink
    14.  _defer       *_defer // innermost defer
    15.  m            *m      // current m; offset known to arm liblink
    16.  sched        gobuf //记录栈指针，和运行到的行数
    17.  syscallsp    uintptr        // if status==Gsyscall, syscallsp = sched.sp to use during gc
    18.  syscallpc    uintptr        // if status==Gsyscall, syscallpc = sched.pc to use during gc
    19.  stktopsp     uintptr        // expected sp at top of stack, to check in traceback
    20.  param        unsafe.Pointer // passed parameter on wakeup
    21.  atomicstatus uint32  //协程状态
    22.  stackLock    uint32 // sigprof/scang lock; TODO: fold in to atomicstatus
    23.  goid         int64  //协程的id
    24.  schedlink    guintptr
    25.  waitsince    int64      // approx time when the g become blocked
    26.  waitreason   waitReason // if status==Gwaiting
    28.  preempt       bool // preemption signal, duplicates stackguard0 = stackpreempt
    29.  preemptStop   bool // transition to _Gpreempted on preemption; otherwise, just deschedule
    30.  preemptShrink bool // shrink stack at synchronous safe point
    32.  // asyncSafePoint is set if g is stopped at an asynchronous
    33.  // safe point. This means there are frames on the stack
    34.  // without precise pointer information.
    35.  asyncSafePoint bool
    37.  paniconfault bool // panic (instead of crash) on unexpected fault address
    38.  gcscandone   bool // g has scanned stack; protected by _Gscan bit in status
    39.  throwsplit   bool // must not split stack
    40.  // activeStackChans indicates that there are unlocked channels
    41.  // pointing into this goroutine's stack. If true, stack
    42.  // copying needs to acquire channel locks to protect these
    43.  // areas of the stack.
    44.  activeStackChans bool
    45.  // parkingOnChan indicates that the goroutine is about to
    46.  // park on a chansend or chanrecv. Used to signal an unsafe point
    47.  // for stack shrinking. It's a boolean value, but is updated atomically.
    48.  parkingOnChan uint8
    50.  raceignore     int8     // ignore race detection events
    51.  sysblocktraced bool     // StartTrace has emitted EvGoInSyscall about this goroutine
    52.  sysexitticks   int64    // cputicks when syscall has returned (for tracing)
    53.  traceseq       uint64   // trace event sequencer
    54.  tracelastp     puintptr // last P emitted an event for this goroutine
    55.  lockedm        muintptr
    56.  sig            uint32
    57.  writebuf       []byte
    58.  sigcode0       uintptr
    59.  sigcode1       uintptr
    60.  sigpc          uintptr
    61.  gopc           uintptr         // pc of go statement that created this goroutine
    62.  ancestors      *[]ancestorInfo // ancestor information goroutine(s) that created this goroutine (only used if debug.tracebackancestors)
    63.  startpc        uintptr         // pc of goroutine function
    64.  racectx        uintptr
    65.  waiting        *sudog         // sudog structures this g is waiting on (that have a valid elem ptr); in lock order
    66.  cgoCtxt        []uintptr      // cgo traceback context
    67.  labels         unsafe.Pointer // profiler labels
    68.  timer          *timer         // cached timer for time.Sleep
    69.  selectDone     uint32         // are we participating in a select and did someone win the race?
    71.  // Per-G GC state
    73.  // gcAssistBytes is this G's GC assist credit in terms of
    74.  // bytes allocated. If this is positive, then the G has credit
    75.  // to allocate gcAssistBytes bytes without assisting. If this
    76.  // is negative, then the G must correct this by performing
    77.  // scan work. We track this in bytes to make it fast to update
    78.  // and check for debt in the malloc hot path. The assist ratio
    79.  // determines how this corresponds to scan work debt.
    80.  gcAssistBytes int64
    81. }

    image.png

  5. runtime中，协程本质是一个g结构体

  6. stack：堆栈地址
  7. gobuf：目前协程运行状态（sp，协程栈。pc 程序运行行数）

  8. atomicstatus：协程状态

    golang将系统线程抽象表达出

    1. type m struct {
    2.  g0      *g     // 初始协程，启动其他协程的协程
    3.  morebuf gobuf  // gobuf arg to morestack
    4.  divmod  uint32 // div/mod denominator for arm - known to liblink
    6.  // Fields not known to debuggers.
    7.  procid        uint64       // for debuggers, but offset not hard-coded
    8.  gsignal       *g           // signal-handling g
    9.  goSigStack    gsignalStack // Go-allocated signal handling stack
    10.  sigmask       sigset       // storage for saved signal mask
    11.  tls           [6]uintptr   // thread-local storage (for x86 extern register)
    12.  mstartfn      func()
    13.  curg          *g       // current running goroutine 正在运行的协程结构体g
    14.  caughtsig     guintptr // goroutine running during fatal signal
    15.  p             puintptr // attached p for executing go code (nil if not executing go code)
    16.  nextp         puintptr
    17.  oldp          puintptr // the p that was attached before executing a syscall
    18.  id            int64 线程id
    19.  mallocing     int32
    20.  throwing      int32
    21.  preemptoff    string // if != "", keep curg running on this m
    22.  locks         int32
    23.  dying         int32
    24.  profilehz     int32
    25.  spinning      bool // m is out of work and is actively looking for work
    26.  blocked       bool // m is blocked on a note
    27.  newSigstack   bool // minit on C thread called sigaltstack
    28.  printlock     int8
    29.  incgo         bool   // m is executing a cgo call
    30.  freeWait      uint32 // if == 0, safe to free g0 and delete m (atomic)
    31.  fastrand      [2]uint32
    32.  needextram    bool
    33.  traceback     uint8
    34.  ncgocall      uint64      // number of cgo calls in total
    35.  ncgo          int32       // number of cgo calls currently in progress
    36.  cgoCallersUse uint32      // if non-zero, cgoCallers in use temporarily
    37.  cgoCallers    *cgoCallers // cgo traceback if crashing in cgo call
    38.  doesPark      bool        // non-P running threads: sysmon and newmHandoff never use .park
    39.  park          note
    40.  alllink       *m // on allm
    41.  schedlink     muintptr
    42.  lockedg       guintptr
    43.  createstack   [32]uintptr // stack that created this thread.
    44.  lockedExt     uint32      // tracking for external LockOSThread
    45.  lockedInt     uint32      // tracking for internal lockOSThread
    46.  nextwaitm     muintptr    // next m waiting for lock
    47.  waitunlockf   func(*g, unsafe.Pointer) bool
    48.  waitlock      unsafe.Pointer
    49.  waittraceev   byte
    50.  waittraceskip int
    51.  startingtrace bool
    52.  syscalltick   uint32
    53.  freelink      *m // on sched.freem
    55.  // mFixup is used to synchronize OS related m state
    56.  // (credentials etc) use mutex to access. To avoid deadlocks
    57.  // an atomic.Load() of used being zero in mDoFixupFn()
    58.  // guarantees fn is nil.
    59.  mFixup struct {
    60.      lock mutex
    61.      used uint32
    62.      fn   func(bool) bool
    63.  }
    65.  // these are here because they are too large to be on the stack
    66.  // of low-level NOSPLIT functions.
    67.  libcall   libcall
    68.  libcallpc uintptr // for cpu profiler
    69.  libcallsp uintptr
    70.  libcallg  guintptr
    71.  syscall   libcall // stores syscall parameters on windows
    73.  vdsoSP uintptr // SP for traceback while in VDSO call (0 if not in call)
    74.  vdsoPC uintptr // PC for traceback while in VDSO call
    76.  // preemptGen counts the number of completed preemption
    77.  // signals. This is used to detect when a preemption is
    78.  // requested, but fails. Accessed atomically.
    79.  preemptGen uint32
    81.  // Whether this is a pending preemption signal on this M.
    82.  // Accessed atomically.
    83.  signalPending uint32
    85.  dlogPerM
    87.  mOS
    89.  // Up to 10 locks held by this m, maintained by the lock ranking code.
    90.  locksHeldLen int
    91.  locksHeld    [10]heldLockInfo
    92. }

  9. 将系统线程抽象为结构体m

  10. g0:g0协程，操作调度器
  11. curg：current g，目前运行的g

  12. mOS：操作系统线程信息

    协程如何执行的

    在go1.0版本，启动了多线程循环抢占式调用全局协程队列中的协程，要先通过全局协程队列的锁，才能调用协程
    image.png
    image.png

  13. 操作系统不知道协程goroutine的存在

  14. 操作系统线程执行一个调度循环，顺序执行goroutine

  15. 调度循环非常像线程池

    总结

  16. 协程本质是一个g结构体

  17. g结构体记录了sp(协程栈)，pc(程序运行行数)
  18. 最简情况下，线程执行标准调度循环，执行协程

G-M-P调度模型

解决的问题

多线程并发时，会抢夺全局协程队里的锁，造成锁的冲突和锁的等待

p(本地队列)的结构体

  1. type p struct {
  2.     id          int32
  3.     status      uint32 // one of pidle/prunning/...
  4.     link        puintptr
  5.     schedtick   uint32     // incremented on every scheduler call
  6.     syscalltick uint32     // incremented on every system call
  7.     sysmontick  sysmontick // last tick observed by sysmon
  8.     m           muintptr   // 指向的服务的m
  9.     mcache      *mcache
  10.     pcache      pageCache
  11.     raceprocctx uintptr
  13.     deferpool    [5][]*_defer // pool of available defer structs of different sizes (see panic.go)
  14.     deferpoolbuf [5][32]*_defer
  16.     // Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.
  17.     goidcache    uint64
  18.     goidcacheend uint64
  20.     // Queue of runnable goroutines. Accessed without lock.
  21.     //本地队列，可以无锁访问
  22.     runqhead uint32
  23.     runqtail uint32
  24.     runq     [256]guintptr
  25.     // runnext, if non-nil, is a runnable G that was ready'd by
  26.     // the current G and should be run next instead of what's in
  27.     // runq if there's time remaining in the running G's time
  28.     // slice. It will inherit the time left in the current time
  29.     // slice. If a set of goroutines is locked in a
  30.     // communicate-and-wait pattern, this schedules that set as a
  31.     // unit and eliminates the (potentially large) scheduling
  32.     // latency that otherwise arises from adding the ready'd
  33.     // goroutines to the end of the run queue.
  34.     runnext guintptr //下一个可用协程的指针
  36.     // Available G's (status == Gdead)
  37.     gFree struct {
  38.         gList
  39.         n int32
  40.     }
  42.     sudogcache []*sudog
  43.     sudogbuf   [128]*sudog
  45.     // Cache of mspan objects from the heap.
  46.     mspancache struct {
  47.         // We need an explicit length here because this field is used
  48.         // in allocation codepaths where write barriers are not allowed,
  49.         // and eliminating the write barrier/keeping it eliminated from
  50.         // slice updates is tricky, moreso than just managing the length
  51.         // ourselves.
  52.         len int
  53.         buf [128]*mspan
  54.     }
  56.     tracebuf traceBufPtr
  58.     // traceSweep indicates the sweep events should be traced.
  59.     // This is used to defer the sweep start event until a span
  60.     // has actually been swept.
  61.     traceSweep bool
  62.     // traceSwept and traceReclaimed track the number of bytes
  63.     // swept and reclaimed by sweeping in the current sweep loop.
  64.     traceSwept, traceReclaimed uintptr
  66.     palloc persistentAlloc // per-P to avoid mutex
  68.     _ uint32 // Alignment for atomic fields below
  70.     // The when field of the first entry on the timer heap.
  71.     // This is updated using atomic functions.
  72.     // This is 0 if the timer heap is empty.
  73.     timer0When uint64
  75.     // The earliest known nextwhen field of a timer with
  76.     // timerModifiedEarlier status. Because the timer may have been
  77.     // modified again, there need not be any timer with this value.
  78.     // This is updated using atomic functions.
  79.     // This is 0 if the value is unknown.
  80.     timerModifiedEarliest uint64
  82.     // Per-P GC state
  83.     gcAssistTime         int64 // Nanoseconds in assistAlloc
  84.     gcFractionalMarkTime int64 // Nanoseconds in fractional mark worker (atomic)
  86.     // gcMarkWorkerMode is the mode for the next mark worker to run in.
  87.     // That is, this is used to communicate with the worker goroutine
  88.     // selected for immediate execution by
  89.     // gcController.findRunnableGCWorker. When scheduling other goroutines,
  90.     // this field must be set to gcMarkWorkerNotWorker.
  91.     gcMarkWorkerMode gcMarkWorkerMode
  92.     // gcMarkWorkerStartTime is the nanotime() at which the most recent
  93.     // mark worker started.
  94.     gcMarkWorkerStartTime int64
  96.     // gcw is this P's GC work buffer cache. The work buffer is
  97.     // filled by write barriers, drained by mutator assists, and
  98.     // disposed on certain GC state transitions.
  99.     gcw gcWork
  101.     // wbBuf is this P's GC write barrier buffer.
  102.     //
  103.     // TODO: Consider caching this in the running G.
  104.     wbBuf wbBuf
  106.     runSafePointFn uint32 // if 1, run sched.safePointFn at next safe point
  108.     // statsSeq is a counter indicating whether this P is currently
  109.     // writing any stats. Its value is even when not, odd when it is.
  110.     statsSeq uint32
  112.     // Lock for timers. We normally access the timers while running
  113.     // on this P, but the scheduler can also do it from a different P.
  114.     timersLock mutex
  116.     // Actions to take at some time. This is used to implement the
  117.     // standard library's time package.
  118.     // Must hold timersLock to access.
  119.     timers []*timer
  121.     // Number of timers in P's heap.
  122.     // Modified using atomic instructions.
  123.     numTimers uint32
  125.     // Number of timerModifiedEarlier timers on P's heap.
  126.     // This should only be modified while holding timersLock,
  127.     // or while the timer status is in a transient state
  128.     // such as timerModifying.
  129.     adjustTimers uint32
  131.     // Number of timerDeleted timers in P's heap.
  132.     // Modified using atomic instructions.
  133.     deletedTimers uint32
  135.     // Race context used while executing timer functions.
  136.     timerRaceCtx uintptr
  138.     // preempt is set to indicate that this P should be enter the
  139.     // scheduler ASAP (regardless of what G is running on it).
  140.     preempt bool
  142.     pad cpu.CacheLinePad
  143. }
  • p结构体中的m：指向线程
  • 队列的 runqhead：头部队列
  • runqtail：尾队列
  • runq：最大长度为256协程队列
  • runnext：队列中下一个运行的协程

image.png

g-m-p的执行细节

m每次获取协程执行的时候，会先在本地队列p中去调用g，调用完之后释放，然后开始调用下一个g，当本地队列p中的g消耗完之后，会去获取全局队列的锁，然后拿去一部分g，放到本地队列p中。如果全局队列的g没了，就会去其他p中获取g。
image.png

源码分析本地队列无G后

  1. // One round of scheduler: find a runnable goroutine and execute it.
  2. // Never returns.
  3. // 线程循环的方法
  4. func schedule() {
  5.     _g_ := getg()
  6.     .....
  8.     var gp *g
  9.     .....
  11.     // 先到本地队列获取协程
  12.     if gp == nil {
  13.         gp, inheritTime = runqget(_g_.m.p.ptr())
  14.         // We can see gp != nil here even if the M is spinning,
  15.         // if checkTimers added a local goroutine via goready.
  16.     }
  17.     // 上面的本地队列没有g，就会去全局队列或者其他本地队列获取g
  18.     if gp == nil {
  19.         gp, inheritTime = findrunnable() // blocks until work is available
  20.     }
  21.     ......
  24. }

p的作用

  1. M与G之间的中间(送料器)
  2. p持有一些G，使得每次获取G的时候不用从全局找

  3. 大大减少并发冲突的情况

    新建的协程

  4. 随机寻找一个p

  5. 将协程房屋p的runnext，go的调度户优先执行新的协程

  6. 若本地队列满了，将会放入全局队列

    实现协程并发

    解决：协程顺序执行，无法并发的问题

    协程顺序执行容易产生饥饿问题

    当下只有两个M，其中正在执行的G需要较长时间，在本地队列P的G都无法执行，无法进行本地队列循环。
    image.png

    解决本地队列协程饥饿问题

  7. 将正在执行的协程存起来，并停止

  8. 将停止的协程放到runnablue队列的尾部，
  9. 协程机型循环，重新运行新的G

image.png
image.png
该方法：可能会造成全局队列的协程饥饿
image.png

  1. 解决全局队列协程饥饿

go解决饥饿问题的方法：每执行61次协程循环，就会从全局队列中拿一个协程放到本地队列
image.png

切换时机(切换协程的方案)

主动挂起

调用sleep，channel时会主动挂起
image.png

系统条用完成时

如：检查网络状态
image.png

总结

  1. 如果协程顺序执行，会有饥饿问题
  2. 协程执行超时，协程执行中间，将协程挂起，执行其他协程
  3. 完成系统调用时挂起，也可以主动挂起

  4. 防止全局队列饥饿，本地队列随机抽取去全局队列

    抢占式调度

    协作抢占

    解决的问题

  5. 永远不主动挂起

  6. 永远都不系统调用

    抢占

  7. 在go中，方法do1调用方法do2时，总会被系统插入一个方法 runtime.morestack

image.png

  1. 基于morestack方法，进行标记抢占

image.png
image.png

  1. 如果协程循环中的业务方法，执行了morestack方法，会检查协程是不是标记了抢占（系统监控器标记的），标记后就会出现调用schedule（协程循环重新开始）

image.png


  1. 基于信号抢占

    解决的问题

  2. 永远不主动挂起

  3. 永远都不系统调用
  4. 业务执行中无法标记抢占

    抢占

    image.png
    先注册一个信号处理函数，当GC回收时，发现超时协程会触发函数，向目标线程发送信号，然后触发线程循环调度
    image.png
    image.png

总结

  1. 基于系统调用和主动挂起，协程可能无法调度
  2. 基于协作的抢占式调度：业务主动调用morestack()

  3. 基于信号的抢占式调度：强制线程调用doSigPreempt()

    协程太多

    造成的问题

  4. 文件打开数太大

  5. 超过内存限制

  6. 调度开销过大

    处理协程太多的方案

  7. 优化业务逻辑

  8. 利用channel的缓冲
    1. 利用channel的缓冲区
    2. 启动协程前向channel发送一个空结构体
    3. 协程结束取出一个结构体
    4. 适用于构建一大批系统的协程 ```go func do(i int,ch chan struct{}) { fmt.Println(i) time.Sleep(time.Second) <-ch }

func main() { ch := make(chan struct{},3000) for i := 0; i < math.MaxInt32; i++ { ch<- struct{}{} go do(i,ch) } time.Sleep(time.Hour) } ```

  1. 协程池 (tunny)
    1. 预创建一定数量协程
    2. 将任务送入协程池队列
    3. 协程池不断取出可用协程，执行任务

image.png

  1. 调度系统资源