지난 글에서 Golangcontext 탐색에서 context의 용법과 응용 장면을 초보적으로 이해했다.그럼 다음에 원본 코드에 깊이 들어가서 context가 어떻게 실현되는지 배워봅시다.

emptyCtx

context 패키지의 코드가 매우 적습니다. 하나의context.go 파일, 총 480줄 코드, 그중에 대량의 주석도 포함.context 패키지는 먼저 Context 인터페이스를 정의합니다.

type Context interface {
    Deadline() (deadline time.Time, ok bool)

    Done() 

다음은 emptyCtx 유형을 정의합니다.

// An emptyCtx is never canceled, has no values, and has no deadline. It is not
// struct{}, since vars of this type must have distinct addresses.
type emptyCtx int

왜 emptyCtx라고 해요?주석emptyCtx은 취소될 수 없고 값도 없고 deadline도 없다고 했습니다.이 동시에 emptyCtx도 하나struct{}가 아니다. 왜냐하면 이런 유형의 변수는 서로 다른 주소가 필요하기 때문이다.이것emptyCtx은 Context 인터페이스를 실현했다.

func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
    return
}

func (*emptyCtx) Done() 

위의 코드를 보면 왜 emptyCtx가 취소될 수 없는지 알 수 있다. 값도 없고 deadline도 없다. 왜냐하면 위의 실현은 모두 직접return이기 때문이다.그럼 이것emptyCtx은 무슨 소용이 있습니까?Background()와TODO() 함수를 기억하십니까?맞습니다. 내부는 바로 되돌아오는 emptyCtx 유형의 지침입니다.

var (
    background = new(emptyCtx)
    todo       = new(emptyCtx)
)

func Background() Context {
    return background
}

func TODO() Context {
    return todo
}

그래서 이 두 함수는 일반적으로 main 함수, 초기화, 테스트 및 상부 요청의Context에 사용된다.오케이, 계속 내려봐.emptyCtx유형이 아무것도 하지 않는 이상 관련 기능을 실현하는 다른 유형이 있어야 한다. 즉cancelCtx,timerCtx,valueCtx 세 가지 유형이다.다음은 이 세 가지 유형을 말씀드리겠습니다.

Cancel

앞의 글에서 알 수 있듯이 WithCancel, WithTimeout, WithDeadline 이 세 가지 방법은 CancelFunc 유형의 함수를 되돌려주고Context 내부에 canceler 인터페이스를 정의했다.

type canceler interface {
    cancel(removeFromParent bool, err error)
    Done() 

canceler는 바로 취소될 수 있는 context 유형이다. 이따가 계속 아래를 보면 cancelCtx와timerCtx는Context 인터페이스(익명 멤버 변수를 통해)뿐만 아니라canceler 인터페이스도 실현되었다.

cancelCtx

cancelCtx의 구조체 정의:

type cancelCtx struct {
    Context

    done chan struct{} // closed by the first cancel call.

    mu       sync.Mutex
    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() 

우리가 WithCancel를 호출할 때 실제로 되돌아오는 것은 cancelCtx 지침과 cancel() 방법이다.

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
    c := newCancelCtx(parent)
    propagateCancel(parent, &c)
    return &c, func() { c.cancel(true, Canceled) }
}

// newCancelCtx returns an initialized cancelCtx.
func newCancelCtx(parent Context) cancelCtx {
    return cancelCtx{
        Context: parent,
        done:    make(chan struct{}),
    }
}

그럼, propagateCancel 함수는 또 무엇을 하는 것입니까?

//               context，  context  parent.Children 
// propagateCancel arranges for child to be canceled when parent is.
func propagateCancel(parent Context, child canceler) {
    if parent.Done() == nil {
        return // parent is never canceled
    }
    //      parent   cancelCtx
    if p, ok := parentCancelCtx(parent); ok {
        p.mu.Lock()
        if p.err != nil {
            // 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{}{}
        }
        p.mu.Unlock()
    } else {
        go func() {
            select {
            case 

Timer

WithTimeout와WithDeadline는 사실 차이가 많지 않다. 단지 원본 코드 내부에서 우리를 도와 봉인할 뿐이다.

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
    return WithDeadline(parent, time.Now().Add(timeout))
}

func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) {
    //    deadline   deadline   ，    
    if cur, ok := parent.Deadline(); ok && cur.Before(deadline) {
        // The current deadline is already sooner than the new one.
        return WithCancel(parent)
    }
    c := &timerCtx{
        cancelCtx: newCancelCtx(parent),
        deadline:  deadline,
    }
    propagateCancel(parent, c)
    d := time.Until(deadline)
    // deadline    ，       
    if d <= 0 {
        c.cancel(true, DeadlineExceeded) // deadline has already passed
        return c, func() { c.cancel(true, Canceled) }
    }
    c.mu.Lock()
    defer c.mu.Unlock()
    if c.err == nil {
        //   d         
        c.timer = time.AfterFunc(d, func() {
            c.cancel(true, DeadlineExceeded)
        })
    }
    return c, func() { c.cancel(true, Canceled) }
}

timerCtx의 코드도 비교적 간결하게 구현되었다.

type timerCtx struct {
    cancelCtx
    timer *time.Timer // Under cancelCtx.mu.

    deadline time.Time
}

func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
    return c.deadline, true
}

func (c *timerCtx) String() string {
    return fmt.Sprintf("%v.WithDeadline(%s [%s])", c.cancelCtx.Context, c.deadline, time.Until(c.deadline))
}

func (c *timerCtx) cancel(removeFromParent bool, err error) {
    c.cancelCtx.cancel(false, err)
    if removeFromParent {
        // Remove this timerCtx from its parent cancelCtx's children.
        removeChild(c.cancelCtx.Context, c)
    }
    c.mu.Lock()
    if c.timer != nil {
        c.timer.Stop()
        c.timer = nil
    }
    c.mu.Unlock()
}

여기서 주의해야 할 것은 timerCtx가 직접 canceler 인터페이스를 실현한 것이 아니라 익명 구성원 변수를 사용했기 때문에 Context 인터페이스를 다시 한 번 실현하지 않고 필요에 따라 Deadline 방법만 실현할 수 있다는 것이다.timerCtx의cancel방법은 cancelCtx의cancel방법을 먼저 사용한 다음에 타이머를 정지시킨다.

Value

먼저 valueCtx의 정의를 살펴보자.

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)
}

이것은 가장 간단한 Context 구현입니다. 익명 변수인 Context 외에 두 개의 키,value 변수를 추가하여 값을 저장합니다.WithValue의 실현을 살펴보자.

func WithValue(parent Context, key, val interface{}) Context {
    if key == nil {
        panic("nil key")
    }
    if !reflect.TypeOf(key).Comparable() {
        panic("key is not comparable")
    }
    return &valueCtx{parent, key, val}
}

주의해야 할 것은 키가 nil일 수 없고 반드시 비교할 수 있어야 한다는 것이다. 그렇지 않으면panic를 초래할 수 있다!비교할 수 있는 것은 키가 함수 유형이나 NaN 같은 것이 될 수 없다는 뜻이다. 구체적으로는reflect 패키지를 볼 수 있다. 여기서 자세히 설명하지 않겠다.

최후

전체context를 보면 context가 어떻게 실현되었는지에 대한 명확한 이해도 있고 context 패키지에 대량의 테스트 코드가 있어서 대단합니다!최근에 고의 원본 코드를 보면서 정말 좋은 학습 자료라는 것을 발견했습니다. 간단명료한 코드를 어떻게 쓰는지에 도움이 됩니다.