func (c *Cond) Wait()

c.L.Lock()
for !condition() {
    c.Wait()
}
... make use of condition ...
c.L.Unlock()

func (*Cond) Signal

func (*Cond) Broadcast

type Mutex struct {
	state int32 # 状态
	sema  uint32 # 信号量字段semaphore
}

func (m *Mutex) Lock()

# Lock 函数,使用CAS算法，如果锁状态是0，期望值也是0，就修改为1，如果再次加锁时，内存值是1，期望值是0，操作就是失败，得到的就是false;第一次加锁时m.state是0
if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
		if race.Enabled {
			race.Acquire(unsafe.Pointer(m))
		}
		return
	}
	.....
# 如果再次加锁就会进入go等待队列中。如果lifo为true,队列等待在等待队列的头部。	
# m.sema 是信号量,这个方法可Semacquire方法一样，是为了Mutexes实现的，如果lifo为true，则在等待队列的头部排队服务员
runtime_SemacquireMutex(&m.sema, queueLifo)

# Semacquire等待直到* s> 0然后以原子方式递减它。
func runtime_Semacquire(s *uint32)

func (m *Mutex) Unlock()
# 解锁的时候就进行m.state原子加-1，如果多次解锁就会运行时异常。
new := atomic.AddInt32(&m.state, -mutexLocked)
if (new+mutexLocked)&mutexLocked == 0 {
		throw("sync: unlock of unlocked mutex")
	}
....
# 这个方法主要是执行原子的递增m.sema,并通知一个阻塞在Semacquire的等待goroutines
runtime_Semrelease(&m.sema, false)

func (o *Once) Do(f func()) {
	if atomic.LoadUint32(&o.done) == 1 {
		return
	}
	// Slow-path.
	o.m.Lock()
	defer o.m.Unlock()
	if o.done == 0 {
		defer atomic.StoreUint32(&o.done, 1)
		f()
	}
}

once.Do(func() {
		once.Do(func() {
			f("test")
		})
	})

type RWMutex struct {
	w           Mutex  // 写互斥锁
	writerSem   uint32 // 写信号量
	readerSem   uint32 // 读信号量
	readerCount int32  // 读阻塞的数量
	readerWait  int32  // 读放弃的数量
}
const rwmutexMaxReaders = 1 << 30

func (rw *RWMutex) Lock 

func (rw *RWMutex) RLock 

func (rw *RWMutex) RLocker

func (rw *RWMutex) RUnlock 

func (rw *RWMutex) Unlock

type Context interface {
    //子go用于监听父go是否发起结束当前go的消息
    Done() <-chan struct{}
    // 返回关闭的原因
    Err() error
    //返回到期时间，比如设置了5s取消，那返回的值就是5s后的时间，ok is true if your setting deadling
    Deadline() (deadline time.Time, ok bool)
    //从context中取出key的值
    Value(key interface{}) interface{}
}

# 设置超时返回，并返回一个新的context
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
# 没有超时时间，只是用于通知子go执行关闭
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
# 设置一个值到context中，并返回一个新的ctx
func WithValue(parent Context, key, val interface{}) Context

func main() {

	http.HandleFunc("/demo",demo)
	http.ListenAndServe(":8888",nil)
}
func demo(w http.ResponseWriter,r *http.Request)  {
	timeout, err := time.ParseDuration(r.FormValue("timeout"))
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	var (
		ctx context.Context
		cancel context.CancelFunc
	)
	if err != nil {
		ctx, cancel = context.WithTimeout(r.Context(), timeout)
	}else {
		ctx,cancel = context.WithCancel(r.Context())
	}

	defer cancel()
	database := getDatabaseData(ctx)
	age,ct := gRpcServer(ctx)
	if deadline, ok := ctx.Deadline() ; ok {
		fmt.Println(deadline.String())
		fmt.Println(time.Now().String())
	}
	if err := ctx.Err(); err != nil {
		fmt.Println(err)
	}
	if value := ct.Value(ageKey); value != nil {
		fmt.Println("value:",value)
	}
	fmt.Fprint(w,fmt.Sprintf("Database:%s\nAge:%d",database,age))
}


func getDatabaseData(ctx context.Context) string {
	c := make(chan string)
	go func() {
		time.Sleep(time.Second*2)
		c <- "database"
	}()
	select {
	case <- ctx.Done():
		return ""
	case r := <- c:
		return r
	}
}

func gRpcServer(ctx context.Context) (int,context.Context) {
	c := make(chan int)
	go func() {
		time.Sleep(2*time.Second)
		c <- 24
	}()
	ct := context.WithValue(ctx, ageKey, ageKey)
	select {
	case <- ctx.Done():
		return 0,ct
	case v := <- c:
		return v,ct
	}
}

func getDatabaseData(ctx context.Context) string {
	c := make(chan string)
	go func() {
		time.Sleep(time.Second*2)
		c <- "database"
	}()
	select {
	case <- ctx.Done():
	    <- c //在此等待c返回，但是这样就会阻塞http请求，就会出现变成同步操作。
		return ""
	case r := <- c:
		return r
	}
}
# 下一个方法同上

func getDatabaseData(ctx context.Context) string {
	c := make(chan string)
	go func() {
	    // 如果加入关闭通道的操作，那就一定要加捕获panic的操作，不然会导致程序推出。因为发送到一个关闭的chan中会出现panic
	    defer func() {
			if err := recover() ; err != nil {

			}
		}()
		time.Sleep(time.Second*2)
		c <- "database"
	}()
	select {
	case <- ctx.Done():
	    close(c)
		return ""
	case r := <- c:
		return r
	}
}