Master Go의 동시성: 컨텍스트 전파 및 취소 비밀 공개-Golang-php.cn

Master Go

Go의 동시성 모델은 획기적인 것이지만 복잡한 동시 작업을 관리하는 것은 까다로울 수 있습니다. 여기서 컨텍스트 전파와 취소가 필요합니다. 이러한 강력한 도구를 사용하면 여러 고루틴은 물론 네트워크 경계까지 포괄하는 강력하고 취소 가능한 작업을 구축할 수 있습니다.

기본부터 시작하겠습니다. 컨텍스트 패키지는 API 경계와 프로세스 간에 마감일, 취소 신호 및 요청 범위 값을 전달하는 방법을 제공합니다. 장기 실행 작업을 제어하고 서비스를 정상적으로 종료하는 비법입니다.

다음은 취소에 컨텍스트를 사용하는 간단한 예입니다.

func longRunningOperation(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
            // Do some work
        }
    }
}

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

    if err := longRunningOperation(ctx); err != nil {
        log.Printf("Operation cancelled: %v", err)
    }
}

로그인 후 복사

이 예에서는 시간 제한이 5초인 컨텍스트를 생성합니다. 해당 시간 내에 작업이 완료되지 않으면 자동으로 취소됩니다.

그러나 컨텍스트는 시간 초과에만 적용되는 것이 아닙니다. 이를 사용하여 여러 고루틴에 취소 신호를 전파할 수 있습니다. 이는 복잡한 작업 흐름을 관리하는 데 매우 유용합니다.

분산 거래 시스템을 구축하는 시나리오를 생각해 보세요. 단일 트랜잭션에 여러 개의 마이크로서비스가 포함될 수 있으며, 일부가 실패하면 전체 트랜잭션이 롤백되도록 해야 합니다.

컨텍스트를 사용하여 이를 구성하는 방법은 다음과 같습니다.

func performTransaction(ctx context.Context) error {
    // Start the transaction
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    defer tx.Rollback() // Will be no-op if tx.Commit() is called

    // Perform multiple operations
    if err := operation1(ctx); err != nil {
        return err
    }
    if err := operation2(ctx); err != nil {
        return err
    }
    if err := operation3(ctx); err != nil {
        return err
    }

    // If we've made it this far, commit the transaction
    return tx.Commit()
}

func operation1(ctx context.Context) error {
    // Make an HTTP request to another service
    req, err := http.NewRequestWithContext(ctx, "GET", "http://service1.example.com", nil)
    if err != nil {
        return err
    }
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    // Process the response...
    return nil
}

로그인 후 복사

이 예에서는 컨텍스트를 사용하여 데이터베이스 작업과 HTTP 요청 모두에 취소를 전파합니다. 시간 초과 또는 명시적 취소로 인해 언제든지 컨텍스트가 취소되면 모든 작업이 종료되고 리소스가 정리됩니다.

하지만 취소를 더욱 세밀하게 제어해야 하는 경우에는 어떻게 해야 할까요? 바로 여기에서 사용자 정의 컨텍스트 유형이 사용됩니다. 도메인별 취소 신호를 전달하는 고유한 컨텍스트 유형을 생성할 수 있습니다.

다음은 "우선순위" 값을 전달하는 사용자 정의 컨텍스트의 예입니다.

type priorityKey struct{}

func WithPriority(ctx context.Context, priority int) context.Context {
    return context.WithValue(ctx, priorityKey{}, priority)
}

func GetPriority(ctx context.Context) (int, bool) {
    priority, ok := ctx.Value(priorityKey{}).(int)
    return priority, ok
}

func priorityAwareOperation(ctx context.Context) error {
    priority, ok := GetPriority(ctx)
    if !ok {
        priority = 0 // Default priority
    }

    // Use the priority to make decisions...
    switch priority {
    case 1:
        // High priority operation
    case 2:
        // Medium priority operation
    default:
        // Low priority operation
    }

    return nil
}

로그인 후 복사

이 사용자 정의 컨텍스트를 사용하면 취소 신호와 함께 우선순위 정보를 전파하여 동시 작업을 더욱 효과적으로 제어할 수 있습니다.

이제 우아한 종료에 대해 이야기해 보겠습니다. 장기 실행 서비스를 구축할 때는 작업이 중단되거나 리소스가 정리되지 않은 상태로 두지 않도록 종료 신호를 적절하게 처리하는 것이 중요합니다.

컨텍스트를 사용하여 우아한 종료를 구현하는 방법은 다음과 같습니다.

func main() {
    // Create a context that's cancelled when we receive an interrupt signal
    ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
    defer cancel()

    // Start our main service loop
    errChan := make(chan error, 1)
    go func() {
        errChan <- runService(ctx)
    }()

    // Wait for either the service to exit or a cancellation signal
    select {
    case err := <-errChan:
        if err != nil {
            log.Printf("Service exited with error: %v", err)
        }
    case <-ctx.Done():
        log.Println("Received shutdown signal. Gracefully shutting down...")
        // Perform any necessary cleanup
        // Wait for ongoing operations to complete (with a timeout)
        cleanupCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
        defer cancel()
        if err := performCleanup(cleanupCtx); err != nil {
            log.Printf("Cleanup error: %v", err)
        }
    }
}

func runService(ctx context.Context) error {
    // Run your service here, respecting the context for cancellation
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
            // Do some work
        }
    }
}

func performCleanup(ctx context.Context) error {
    // Perform any necessary cleanup operations
    // This could include closing database connections, flushing buffers, etc.
    return nil
}

로그인 후 복사

이 설정을 통해 서비스가 인터럽트 신호를 받으면 정상적으로 종료되어 리소스를 정리하고 진행 중인 작업을 완료할 시간을 확보할 수 있습니다.

Go 컨텍스트 시스템의 가장 강력한 측면 중 하나는 네트워크 경계를 넘어 취소를 전파하는 기능입니다. 이는 운영이 여러 서비스에 걸쳐 있을 수 있는 분산 시스템을 구축할 때 특히 유용합니다.

마이크로서비스 아키텍처에서 이를 구현하는 방법의 예를 살펴보겠습니다.

func longRunningOperation(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
            // Do some work
        }
    }
}

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

    if err := longRunningOperation(ctx); err != nil {
        log.Printf("Operation cancelled: %v", err)
    }
}

로그인 후 복사

이 예에서는 쿼리 매개변수를 기반으로 시간 초과가 있는 컨텍스트를 생성합니다. 그런 다음 이 컨텍스트는 모든 후속 API 호출을 통해 전파됩니다. 시간 초과에 도달하면 진행 중인 모든 작업이 취소되고 클라이언트에 오류가 반환됩니다.

이 패턴을 사용하면 클라이언트가 응답 대기를 포기한 후에도 오랫동안 계속되는 "폭주" 작업이 발생하지 않습니다. 이는 응답성이 뛰어나고 리소스 효율적인 분산 시스템을 구축하는 핵심 부분입니다.

동시 시스템에서 오류를 처리하는 것은 까다로울 수 있지만 여기에서도 컨텍스트가 도움이 될 수 있습니다. 컨텍스트를 사용하면 오류가 올바르게 전파되고 오류가 발생하더라도 리소스가 정리되는지 확인할 수 있습니다.

다음은 동시 작업에서 오류를 처리하는 방법의 예입니다.

func performTransaction(ctx context.Context) error {
    // Start the transaction
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    defer tx.Rollback() // Will be no-op if tx.Commit() is called

    // Perform multiple operations
    if err := operation1(ctx); err != nil {
        return err
    }
    if err := operation2(ctx); err != nil {
        return err
    }
    if err := operation3(ctx); err != nil {
        return err
    }

    // If we've made it this far, commit the transaction
    return tx.Commit()
}

func operation1(ctx context.Context) error {
    // Make an HTTP request to another service
    req, err := http.NewRequestWithContext(ctx, "GET", "http://service1.example.com", nil)
    if err != nil {
        return err
    }
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    // Process the response...
    return nil
}

로그인 후 복사

이 예에서는 채널을 사용하여 고루틴의 오류를 다시 기본 함수로 전달합니다. 취소 상황도 확인하고 있습니다. 이를 통해 작업 자체의 오류와 컨텍스트의 취소를 모두 처리할 수 있습니다.

컨텍스트에서 흔히 간과되는 측면 중 하나는 요청 범위 값을 전달하는 능력입니다. 이는 요청 ID, 인증 토큰, 기타 메타데이터 등을 API 경계를 넘어 전파하는 데 매우 유용할 수 있습니다.

다음은 이를 어떻게 사용할 수 있는지에 대한 예입니다.

type priorityKey struct{}

func WithPriority(ctx context.Context, priority int) context.Context {
    return context.WithValue(ctx, priorityKey{}, priority)
}

func GetPriority(ctx context.Context) (int, bool) {
    priority, ok := ctx.Value(priorityKey{}).(int)
    return priority, ok
}

func priorityAwareOperation(ctx context.Context) error {
    priority, ok := GetPriority(ctx)
    if !ok {
        priority = 0 // Default priority
    }

    // Use the priority to make decisions...
    switch priority {
    case 1:
        // High priority operation
    case 2:
        // Medium priority operation
    default:
        // Low priority operation
    }

    return nil
}

로그인 후 복사

이 예에서는 미들웨어를 사용하여 요청 ID를 컨텍스트에 추가합니다. 그런 다음 이 요청 ID를 검색하여 이 컨텍스트를 수신하는 후속 핸들러 또는 함수에서 사용할 수 있습니다.

마무리하면서 맥락은 강력한 도구이기는 하지만 만병통치약은 아니라는 점을 주목할 가치가 있습니다. 컨텍스트를 과도하게 사용하면 코드를 이해하고 유지 관리하기 어려울 수 있습니다. 컨텍스트를 현명하게 사용하고 API를 신중하게 설계하는 것이 중요합니다.

컨텍스트의 주요 용도는 API 경계를 넘어 마감일, 취소 신호 및 요청 범위 값을 전달하는 것이어야 합니다. 선택적 매개변수를 함수에 전달하기 위한 범용 메커니즘이 아닙니다.

결론적으로 컨텍스트 전파 및 취소를 포함한 Go의 동시성 모델을 마스터하는 것은 강력하고 효율적이며 확장 가능한 애플리케이션을 구축하는 데 중요합니다. 이러한 도구를 활용함으로써 우리는 복잡한 워크플로를 원활하게 처리하고, 리소스를 효과적으로 관리하며, 변화하는 조건에 지능적으로 대응하는 시스템을 만들 수 있습니다. 동시 프로그래밍으로 가능한 것의 한계를 계속해서 확장함에 따라 이러한 기술은 우리 도구 상자에서 더욱 중요해질 것입니다.