type User struct {...}

// 定义一种类型key ,注意这里是小写的 ，即在package 外部是无法访问到key
// 这样就可以保证对只能在package user 中使用key类型
// 每个package 中都定义一个相应的key ,
type key int

// Context 中会有各种类型的数据，每种数据有一个key
// 以userKey 为user.User对应的key,userKey 未导出， 即在package user
// 外部无法访问到userKey,对它的访问，使用下面提供的user.NewContext
// 和 user.FromContext 来存储和访问
// 不要直接使用这个变量
var userKey key = 0

// 把u 存储到Context 中， (使用上面定义的userKey变量作为key)
func NewContext(ctx context.Context, u *User) context.Context {
    return context.WithValue(ctx, userKey, u)
}

// 从Context 中 取回userKey 对应的user.User
func FromContext(ctx context.Context) (*User, bool) {
    u, ok := ctx.Value(userKey).(*User)
    return u, ok
}

package main

import (

    "golang.org/x/net/context"
)

func main() {
    ctx := context.Background() // 最基础的一个Context ，里面什么都没存储
    u := user.User{}
    ctx = ctx.NewContext(ctx, &u) // 把 *user.User 类型的u  存一ctx 中
    // 假如 还有另一个package 叫， group

    g := group.Group{}
    ctx = ctx.NewContext(ctx, &g) // 把 *group.Group 类型的g  存一ctx 中
    // 现在 ctx 中存了user 和group 的数据，
    // ctx 会做为参数在 各个函数中进行传递
    // 例如在某个函数用， 你需要访问里面的user
    // 通过下面这种方式来获得
    u, ok := user.FromContext(ctx)
    g, ok := group.Fromcontext(ctx)
    // 注意到存到context 中的数据基本都是指针类型， 即需要修改数据时，只需要修改即可
    // 不需要把指针重新存到context 中，似乎 若不存指针而是存struct结构的话， 反复的NewContext
    // 会导致context 中的数据无限增大
}

// Use context Values only for request-scoped data that transits processes and
// APIs, not for passing optional parameters to functions.
func WithValue(parent Context, key interface{}, val interface{}) Context {
    return &valueCtx{parent, key, val}
}

// A valueCtx carries a key-value pair.  It implements Value for that key and
// delegates all other calls to the embedded Context.
type valueCtx struct {
    Context
    key, val interface{}
}

func (c *valueCtx) String() string {
    return fmt.Sprintf("%v.WithValue(%#v, %#v)", c.Context, c.key, c.val)
}

func (c *valueCtx) Value(key interface{}) interface{} {
    if c.key == key {
	return c.val
    }
    return c.Context.Value(key)
}

package main

import (
    "fmt"
    "net/http"
    "time"

    "golang.org/x/net/context"
)

func doALongJob(r chan string) {
    time.Sleep(time.Second * 5)
    fmt.Println("job is done")
    r <- "经历了漫长的过程，用户等到了想要的数据"
    fmt.Println("doALongJob is end")
}
func handleTest(w http.ResponseWriter, req *http.Request) {
    defer req.Body.Close()
    ctx := context.Background()
    var cancel context.CancelFunc
    ctx, cancel = context.WithCancel(ctx)
    defer cancel()
    go func() {
	// 我 （别的进程 ） 可以让本进程取消等待数据的返回
	time.Sleep(2 * time.Second)
	fmt.Println("等不及了， 不再等待")
	// 如果此处没有调用cancel() ,浏览器上会一直等到 想过的结果
	cancel()
    }()

    // 这里缓冲1个， 即 ，就算我放弃从resultChan 读数据，doALongJob处依然可以往里面写入一个数据，从而正常退出
    var reusultChan chan string = make(chan string, 1)
    go doALongJob(reusultChan)
    select {
    case <-ctx.Done():
	fmt.Println("走到ctx.Done()，分支，说明用户不愿意继续等待了 with err:", ctx.Err())
	w.Write([]byte("走到ctx.Done()，分支，说明用户不愿意继续等待了 with err:" + ctx.Err().Error()))
    case result := <-reusultChan:
	w.Write([]byte(result))
	fmt.Println(result)
    }

}
func main() {
    http.HandleFunc("/", handleTest)
    http.ListenAndServe(":8080", nil)
}

parentCtx, parentCancel := WithCancel(context.Background())
childCtx, childCancel := WithCancel(parentCtx)
var reusultChan chan string = make(chan string, 1)
go doALongJob(reusultChan)
go func() {
    time.Sleep(1 * time.Second)//只等一秒，一秒后 doALongJob 还不返回结果
    //注意这里是对parentCancel()的调用，按照context设计的目的，
    // 兼听childCtx.Done()的chan 也是可以收到parentCancel()被调用的事件的
    parentCancel()
}()
select {
case <-childCtx.Done():				// 等待 childCtx 收到cancel事件
     fmt.Println("canceled")
case result := <-reusultChan:
}

package main

import (
	"context"
	"fmt"
	"net/http"
	"sync"
	"time"
)

// DeadlineExceeded is the error returned by context.Context.Err when the context's
// deadline passes.

// WithCancel returns a copy of parent with a new Done channel. The returned
// context's Done channel is closed when the returned cancel function is called
// or when the parent context's Done channel is closed, whichever happens first.
//
// Canceling this context releases resources associated with it, so code should
// call cancel as soon as the operations running in this context.Context complete.
func WithCancel(parent context.Context) (ctx context.Context, cancel context.CancelFunc) {
	c := newCancelCtx(parent)
	propagateCancel(parent, &c)
	return &c, func() { c.cancel(true, context.Canceled) }
}

// newCancelCtx returns an initialized cancelCtx.
func newCancelCtx(parent context.Context) cancelCtx {
	return cancelCtx{Context: parent}
}

// propagateCancel arranges for child to be canceled when parent is.
func propagateCancel(parent context.Context, child canceler) {
	if parent.Done() == nil {
		fmt.Println("parent is never canceled")
		return // parent is never canceled
	}
	fmt.Println("checkparent")
	if p, ok := parentCancelCtx(parent); ok {
		p.mu.Lock()
		if p.err != nil {
			// parent has already been canceled
			fmt.Println("checkparent parent has already been canceled")
			child.cancel(false, p.err)
		} else {
			if p.children == nil {
				p.children = make(map[canceler]struct{})
			}
			p.children[child] = struct{}{}
			fmt.Println("checkparent put child into parent.childrens")
		}
		p.mu.Unlock()
	} else {
		fmt.Println("checkparent  do not understand here ")
		go func() {
			select {
			case <-parent.Done():
				fmt.Println("candgo")
				child.cancel(false, parent.Err())
			case <-child.Done():
				fmt.Println("done")
			}
		}()
	}
}

// parentCancelCtx follows a chain of parent references until it finds a
// *cancelCtx. This function understands how each of the concrete types in this
// package represents its parent.
func parentCancelCtx(parent context.Context) (*cancelCtx, bool) {
	for {
		switch c := parent.(type) {
		case *cancelCtx:
			return c, true
		default:
			return nil, false
		}
	}
}

// removeChild removes a context from its parent.
func removeChild(parent context.Context, child canceler) {
	p, ok := parentCancelCtx(parent)
	if !ok {
		return
	}
	p.mu.Lock()
	if p.children != nil {
		delete(p.children, child)
	}
	p.mu.Unlock()
}

// A canceler is a context type that can be canceled directly. The
// implementations are *cancelCtx and *timerCtx.
type canceler interface {
	cancel(removeFromParent bool, err error)
	Done() <-chan struct{}
}

// closedchan is a reusable closed channel.
var closedchan = make(chan struct{})

func init() {
	close(closedchan)
}

// A cancelCtx can be canceled. When canceled, it also cancels any children
// that implement canceler.
type cancelCtx struct {
	context.Context

	mu       sync.Mutex            // protects following fields
	done     chan struct{}         // created lazily, closed by first cancel call
	children map[canceler]struct{} // set to nil by the first cancel call
	err      error                 // set to non-nil by the first cancel call
}

func (c *cancelCtx) Done() <-chan struct{} {
	c.mu.Lock()
	if c.done == nil {
		c.done = make(chan struct{})
	}
	d := c.done
	c.mu.Unlock()
	return d
}

func (c *cancelCtx) Err() error {
	c.mu.Lock()
	err := c.err
	c.mu.Unlock()
	return err
}

func (c *cancelCtx) String() string {
	return fmt.Sprintf("%v.WithCancel", c.Context)
}

// cancel closes c.done, cancels each of c's children, and, if
// removeFromParent is true, removes c from its parent's children.
func (c *cancelCtx) cancel(removeFromParent bool, err error) {
	fmt.Println("cancel() is called removeFromParent:", removeFromParent)
	if err == nil {
		panic("context: internal error: missing cancel error")
	}
	c.mu.Lock()
	if c.err != nil {
		c.mu.Unlock()
		fmt.Println("already canceled")
		return // already canceled
	}
	c.err = err
	if c.done == nil {
		fmt.Println("nobody care whether the cancelCtx is done,so do not need call close chan to notify")
		c.done = closedchan
	} else {
		fmt.Println("closeddone")
		close(c.done)
	}
	for child := range c.children {
		// NOTE: acquiring the child's lock while holding parent's lock.
		child.cancel(false, err)
	}
	c.children = nil
	c.mu.Unlock()

	if removeFromParent {
		removeChild(c.Context, c)
	}
}

func doALongJob(r chan string) {
	time.Sleep(time.Second * 5)
	fmt.Println("job is done")
	r <- "经历了漫长的过程，用户等到了想要的数据"
	fmt.Println("doALongJob is end")
}
func handleTest(w http.ResponseWriter, req *http.Request) {
	start := time.Now()
	defer req.Body.Close()
	ctx, cancel := WithCancel(context.Background())
	fmt.Println("trying create child cancelctx")
	ctx, cancel2 := WithCancel(ctx)
	go func() {
		// 我 （别的进程 ） 可以让本进程取消等待数据的返回
		time.Sleep(1 * time.Second)
		fmt.Println("parent.ancelctx() 不再等待")
		fmt.Println("trying call parent.cancel()")
		cancel()
	}()
	go func() {
		// 我 （别的进程 ） 可以让本进程取消等待数据的返回
		time.Sleep(2 * time.Second)
		fmt.Println("child.cancel()is called,donot want to wait")
		// 如果此处没有调用cancel() ,浏览器上会一直等到 想过的结果
		cancel2()
	}()

	// 这里缓冲1个， 即 ，就算我放弃从resultChan 读数据，doALongJob处依然可以往里面写入一个数据，从而正常退出
	var reusultChan chan string = make(chan string, 1)
	go doALongJob(reusultChan)
	select {
	case <-ctx.Done():
		fmt.Println("走到ctx.Done()，分支，说明用户不愿意继续等待了 with err:", ctx.Err())
		w.Write([]byte("after seconds,got the result:" + time.Since(start).String()))
		w.Write([]byte("走到ctx.Done()，分支，说明用户不愿意继续等待了 with err:" + ctx.Err().Error()))
	case result := <-reusultChan:
		w.Write([]byte("after seconds,got the result:" + time.Since(start).String()))
		w.Write([]byte(result))
		fmt.Println(result)
	}

}
func main() {
	http.HandleFunc("/", handleTest)
	http.ListenAndServe(":8080", nil)
}

package main

import (
    "fmt"
    "net/http"
    "time"

    "context"
    "math/rand"
)

func doALongJob(ctx context.Context, r chan string) {
    time.Sleep(time.Second + time.Second*time.Duration(rand.Intn(5))) // 模拟做一个很费时的操作
    fmt.Println("job is done")
    select {
    case <-ctx.Done(): // job done 后，发现已经超时，不必再将结果仍给r
	close(r)
	fmt.Println("doALongJob found that it already timeout")
    case r <- "经历了漫长的过程，用户等到了想要的数据":
	// 将结果扔给r,等对方接收
    }
    fmt.Println("doALongJob is end")

}

func handleTest(w http.ResponseWriter, req *http.Request) {
    defer req.Body.Close()
    ctx := context.Background()
    var cancel context.CancelFunc
    ctx, cancel = context.WithTimeout(ctx, time.Second*3)
    defer cancel()

    // 这里缓冲1个， 即 ，就算我放弃从resultChan 读数据，doALongJob处依然可以往里面写入一个数据，从而正常退出
    var reusultChan chan string = make(chan string)
    go doALongJob(ctx, reusultChan)
    select {
    case <-ctx.Done(): // 超时
	fmt.Println("走到ctx.Done()，分支，说明用户不愿意继续等待了 with err:", ctx.Err())
	w.Write([]byte("走到ctx.Done()，分支，说明用户不愿意继续等待了 with err:" + ctx.Err().Error()))
    case result := <-reusultChan:
	w.Write([]byte(result))
	fmt.Println(result)
    }

}

func main() {
    http.HandleFunc("/", handleTest)
    http.ListenAndServe(":8080", nil)
}