func schedinit() {
    // 初始化栈空间复用管理列表
   	stackinit()
    // 初始化当前 M
	mcommoninit(gp.m, -1)
    // 创建GOMAXPro数量的P
    procresize(procs)
}

// 可以调整p的数量，初始化来说肯定是增多
func procresize(nprocs int32) *p {
    // 判断操作略 将allp 数组调整为最新的数量

    // 如果P数量变多，初始化新的p
	for i := old; i < nprocs; i++ {
		pp := allp[i]
		if pp == nil {
			pp = new(p) // P数量增多，需要新建p
		}
		pp.init(i) // 将所有p初始化
		atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp))
	}

    // 如果当前P的id小于新容量即当前P之后会被清理掉，那当前P改为allp[0]
    if gp.m.p != 0 && gp.m.p.ptr().id < nprocs {
            // continue to use the current P
            gp.m.p.ptr().status = _Prunning
            gp.m.p.ptr().mcache.prepareForSweep()
        } else {
            // release the current P and acquire allp[0].
            //
            // We must do this before destroying our current P
            // because p.destroy itself has write barriers, so we
            // need to do that from a valid P.
            if gp.m.p != 0 {
                if trace.enabled {
                    // Pretend that we were descheduled
                    // and then scheduled again to keep
                    // the trace sane.
                    traceGoSched()
                    traceProcStop(gp.m.p.ptr())
                }
                gp.m.p.ptr().m = 0
            }
            gp.m.p = 0
            pp := allp[0]
            pp.m = 0
            pp.status = _Pidle
            acquirep(pp)
            if trace.enabled {
                traceGoStart()
            }
        }



    // 如果我们是缩减p数量的话，那清除多余P,放入复用队列
	for i := nprocs; i < old; i++ {
		pp := allp[i]
		pp.destroy() // 还回mcache
		// can't free P itself because it can be referenced by an M in syscall
	}
    // 除当前p外，所有没有G队列的P放到P空闲队列里面
    for i := nprocs - 1; i >= 0; i-- {
		pp := allp[i]
		if gp.m.p.ptr() == pp {
			continue
		}
		pp.status = _Pidle
		if runqempty(pp) {
			pidleput(pp, now)
		} else {
			pp.m.set(mget())
			pp.link.set(runnablePs)
			runnablePs = pp
		}
	}
    // 返回可运行P链表的头结点，第一个可运行P
    return runnablePs
}

// P清空或重建，进行初始化
func (pp *p) init(id int32) {

    // 分配mcache用于运行时分配对象内存
	if pp.mcache == nil {
		if id == 0 {
			if mcache0 == nil {
				throw("missing mcache?")
			}
			// Use the bootstrap mcache0. Only one P will get
			// mcache0: the one with ID 0.
			pp.mcache = mcache0
		} else {
			pp.mcache = allocmcache()
		}
	}
}

// Create a new g running fn.
// Put it on the queue of g's waiting to run.
// The compiler turns a go statement into a call to this.
func newproc(fn *funcval) {
	gp := getg()
    // 获取当前协程pc计数器，用于创建完继续执行父协程
	pc := getcallerpc()
    // systemstack切换到m的g0系统栈
	systemstack(func() {
        // newproc1执行具体的创建工作
		newg := newproc1(fn, gp, pc)
        // getg返回当前协程(即父线程协程)
		pp := getg().m.p.ptr()
        // 将新创建子协程g放到当前p上
		runqput(pp, newg, true)
        // 
		if mainStarted {
			wakep()
		}
	})
}