golang에서 Context의 사용 시나리오가 무엇인지 알고 계십니까?

다음 칼럼에서는 golang 튜토리얼 칼럼에서 Context in golang의 사용 시나리오를 소개합니다. 필요한 친구들에게 도움이 되길 바랍니다!

golang

context의 Context 사용 시나리오는 Go1.7부터 표준 라이브러리에 포함되었습니다. 한 문장으로 말하면, 고루틴의 수명 주기를 제어하는 ​​것이 주요 용도입니다. 컴퓨팅 작업이 고루틴에 의해 인계되고 어떤 이유로(시간 초과 또는 강제 종료) 고루틴의 컴퓨팅 작업을 중단하려는 경우 이 컨텍스트가 사용됩니다.

이 기사에서는 주로 golang의 컨텍스트 사용 시나리오에 대해 설명합니다.

시나리오 1: RPC 호출

메인 고루틴에는 4개의 RPC가 있으며 RPC2/3/4가 병렬로 요청됩니다. RPC2 요청이 실패하면 오류가 직접 반환되고 계산을 계속하기 위해 RPC3/4가 중지됩니다. 이때 Context가 사용됩니다.

구체적인 구현은 다음과 같습니다.

package main

import (
	"context"
	"sync"
	"github.com/pkg/errors"
)

func Rpc(ctx context.Context, url string) error {
	result := make(chan int)
	err := make(chan error)

	go func() {
		// 进行RPC调用，并且返回是否成功，成功通过result传递成功信息，错误通过error传递错误信息
		isSuccess := true
		if isSuccess {
			result <- 1
		} else {
			err <- errors.New("some error happen")
		}
	}()

	select {
		case <- ctx.Done():
			// 其他RPC调用调用失败
			return ctx.Err()
		case e := <- err:
			// 本RPC调用失败，返回错误信息
			return e
		case <- result:
			// 本RPC调用成功，不返回错误信息
			return nil
	}
}


func main() {
	ctx, cancel := context.WithCancel(context.Background())

	// RPC1调用
	err := Rpc(ctx, "http://rpc_1_url")
	if err != nil {
		return
	}

	wg := sync.WaitGroup{}

	// RPC2调用
	wg.Add(1)
	go func(){
		defer wg.Done()
		err := Rpc(ctx, "http://rpc_2_url")
		if err != nil {
			cancel()
		}
	}()

	// RPC3调用
	wg.Add(1)
	go func(){
		defer wg.Done()
		err := Rpc(ctx, "http://rpc_3_url")
		if err != nil {
			cancel()
		}
	}()

	// RPC4调用
	wg.Add(1)
	go func(){
		defer wg.Done()
		err := Rpc(ctx, "http://rpc_4_url")
		if err != nil {
			cancel()
		}
	}()

	wg.Wait()
}

물론 여기서는 모든 RPC 호출이 완료될 때까지 기본 기능이 종료되지 않도록 하기 위해 waitGroup을 사용합니다.

Rpc 함수에서 첫 번째 매개변수는 마이크인 CancelContext입니다. CancelContext가 생성되면 리스너(ctx)와 마이크(취소 함수)가 반환됩니다. 모든 고루틴은 이 리스너(ctx)를 보유합니다. 메인 고루틴이 모든 고루틴에 곧 종료됨을 알리고 싶을 때 취소 기능을 통해 모든 고루틴에 종료 정보를 알려줍니다. 물론, 모든 고루틴에는 리스너 종료 신호(ctx->Done())를 처리하기 위한 내장 로직이 필요합니다. Rpc 함수 내부를 살펴보고 선택을 사용하여 ctx가 완료된 것과 현재 rpc 호출이 먼저 끝나는 것을 결정할 수 있습니다.

이 waitGroup과 RPC 호출 중 하나는 모든 RPC 로직을 알리는 기능을 이미 수행한 패키지가 있습니다. errorGroup. 이 errorGroup 패키지의 구체적인 사용법은 이 패키지의 테스트 예를 참조하세요.

여기서 cancel()이 여러 번 호출될까봐 걱정하는 사람들도 있습니다. 컨텍스트 패키지의 취소 호출은 멱등성을 갖습니다. 안심하고 여러 번 호출할 수 있습니다.

여기서 살펴보는 것이 좋을 것 같습니다. 여기의 Rpc 함수는 실제로 우리 예에서 "차단" 요청입니다. 이 요청이 http.Get 또는 http.Post를 사용하여 구현되면 실제로는 Rpc 함수의 고루틴입니다. 끝났지만 실제 http.Get inside는 끝나지 않았습니다. 따라서 여기의 기능은 http.Do와 같이 "비차단" 기능이 가장 좋으며 그런 다음 어떤 방식으로든 중단될 수 있다는 점을 이해해야 합니다. 예를 들어 이 문서의 예와 같이 컨텍스트를 사용하여 http.Request 취소:

func httpRequest(
  ctx context.Context,
  client *http.Client,
  req *http.Request,
  respChan chan []byte,
  errChan chan error
) {
  req = req.WithContext(ctx)
  tr := &http.Transport{}
  client.Transport = tr
  go func() {
    resp, err := client.Do(req)
    if err != nil {
      errChan <- err
    }
    if resp != nil {
      defer resp.Body.Close()
      respData, err := ioutil.ReadAll(resp.Body)
      if err != nil {
        errChan <- err
      }
      respChan <- respData
    } else {
      errChan <- errors.New("HTTP request failed")
    }
  }()
  for {
    select {
    case <-ctx.Done():
      tr.CancelRequest(req)
      errChan <- errors.New("HTTP request cancelled")
      return
    case <-errChan:
      tr.CancelRequest(req)
      return
    }
  }
}

http.Client.Do를 사용한 다음 ctx.Done을 ​​수신하면 Transport.CancelRequest를 호출하여 끝납니다.
net/dail/DialContext를 참조할 수도 있습니다
즉, 구현한 패키지를 "중지 가능/제어 가능"하게 하려면 패키지 함수에서 구현한 함수에서 Context를 수신하고 이를 처리하는 것이 가장 좋습니다. 컨텍스트.완료.

시나리오 2: PipeLine

파이프라인 모델은 조립 라인 모델입니다. 조립 라인의 여러 작업자가 n개의 제품을 가지고 하나씩 조립합니다. 실제로 파이프라인 모델의 구현은 컨텍스트와 아무 관련이 없습니다. chan을 사용하여 컨텍스트 없이 파이프라인 모델을 구현할 수도 있습니다. 하지만 전체 파이프라인을 제어하려면 Context를 사용해야 합니다. 이 기사의 Go 파이프라인 패턴 예시는 매우 좋은 예시입니다. 다음은 이 코드에 대한 대략적인 설명입니다.

runSimplePipeline에는 3개의 파이프라인 워커가 있는데, lineListSource는 전송을 위해 매개변수를 하나씩 분할하는 역할을 담당하고, lineParser는 문자열을 int64로 처리하는 역할을 담당하며, 싱크는 특정 값을 기준으로 데이터 사용 가능 여부를 결정합니다. 모든 반환 값에는 기본적으로 두 개의 채널이 있습니다. 하나는 데이터 전달용이고 다른 하나는 오류 전달용입니다. (<-chan 문자열, <-chan 오류) 입력은 기본적으로 두 가지 값을 가지며, 하나는 음성 전송 제어에 사용되는 Context이고 다른 하나는 (<-chan) 입력 제품입니다.

이 세 워커의 특정 기능에서 스위치가 <-ctx.Done() 케이스를 처리하는 데 사용되는 것을 볼 수 있습니다. 이는 생산 라인의 명령 제어입니다.

func lineParser(ctx context.Context, base int, in <-chan string) (
	<-chan int64, <-chan error, error) {
	...
	go func() {
		defer close(out)
		defer close(errc)

		for line := range in {

			n, err := strconv.ParseInt(line, base, 64)
			if err != nil {
				errc <- err
				return
			}

			select {
			case out <- n:
			case <-ctx.Done():
				return
			}
		}
	}()
	return out, errc, nil
}

시나리오 3: 시간 초과 요청

RPC 요청을 보낼 때 이 요청에 시간 초과 제한을 적용하려는 경우가 많습니다. RPC 요청이 10초를 초과하면 자동으로 연결이 끊어집니다. 물론, CancelContext를 사용하여 이 기능을 수행할 수도 있습니다(새 고루틴을 시작하고 이 고루틴은 취소 기능을 보유하며 시간이 다 되면 취소 기능이 호출됩니다).

이 요구 사항은 매우 일반적이므로 컨텍스트 패키지도 이 요구 사항(timerCtx)을 구현합니다. 구체적인 인스턴스화 방법은 WithDeadline 및 WithTimeout입니다.

timerCtx의 특정 로직은 time.AfterFunc를 통해 ctx.cancel을 호출하는 것입니다.

공식 예:

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
    defer cancel()

    select {
    case <-time.After(1 * time.Second):
        fmt.Println("overslept")
    case <-ctx.Done():
        fmt.Println(ctx.Err()) // prints "context deadline exceeded"
    }
}

http 클라이언트에 시간 초과를 추가하는 일반적인 방법이기도 합니다.

uri := "https://httpbin.org/delay/3"
req, err := http.NewRequest("GET", uri, nil)
if err != nil {
	log.Fatalf("http.NewRequest() failed with '%s'\n", err)
}

ctx, _ := context.WithTimeout(context.Background(), time.Millisecond*100)
req = req.WithContext(ctx)

resp, err := http.DefaultClient.Do(req)
if err != nil {
	log.Fatalf("http.DefaultClient.Do() failed with:\n'%s'\n", err)
}
defer resp.Body.Close()

http 서버에서 시간 초과를 설정하는 방법은 무엇인가요?

package main

import (
	"net/http"
	"time"
)

func test(w http.ResponseWriter, r *http.Request) {
	time.Sleep(20 * time.Second)
	w.Write([]byte("test"))
}


func main() {
	http.HandleFunc("/", test)
	timeoutHandler := http.TimeoutHandler(http.DefaultServeMux, 5 * time.Second, "timeout")
	http.ListenAndServe(":8080", timeoutHandler)
}

我们看看TimeoutHandler的内部，本质上也是通过context.WithTimeout来做处理。

func (h *timeoutHandler) ServeHTTP(w ResponseWriter, r *Request) {
  ...
		ctx, cancelCtx = context.WithTimeout(r.Context(), h.dt)
		defer cancelCtx()
	...
	go func() {
    ...
		h.handler.ServeHTTP(tw, r)
	}()
	select {
    ...
	case <-ctx.Done():
		...
	}
}

场景四：HTTP服务器的request互相传递数据

context还提供了valueCtx的数据结构。

这个valueCtx最经常使用的场景就是在一个http服务器中，在request中传递一个特定值，比如有一个中间件，做cookie验证，然后把验证后的用户名存放在request中。

我们可以看到，官方的request里面是包含了Context的，并且提供了WithContext的方法进行context的替换。

package main

import (
	"net/http"
	"context"
)

type FooKey string

var UserName = FooKey("user-name")
var UserId = FooKey("user-id")

func foo(next http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		ctx := context.WithValue(r.Context(), UserId, "1")
		ctx2 := context.WithValue(ctx, UserName, "yejianfeng")
		next(w, r.WithContext(ctx2))
	}
}

func GetUserName(context context.Context) string {
	if ret, ok := context.Value(UserName).(string); ok {
		return ret
	}
	return ""
}

func GetUserId(context context.Context) string {
	if ret, ok := context.Value(UserId).(string); ok {
		return ret
	}
	return ""
}

func test(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("welcome: "))
	w.Write([]byte(GetUserId(r.Context())))
	w.Write([]byte(" "))
	w.Write([]byte(GetUserName(r.Context())))
}

func main() {
	http.Handle("/", foo(test))
	http.ListenAndServe(":8080", nil)
}

在使用ValueCtx的时候需要注意一点，这里的key不应该设置成为普通的String或者Int类型，为了防止不同的中间件对这个key的覆盖。最好的情况是每个中间件使用一个自定义的key类型，比如这里的FooKey，而且获取Value的逻辑尽量也抽取出来作为一个函数，放在这个middleware的同包中。这样，就会有效避免不同包设置相同的key的冲突问题了。

위 내용은 golang에서 Context의 사용 시나리오가 무엇인지 알고 계십니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!