콘텐츠 대표 이미지 - Go 언어 정복기: 요청의 생명주기를 지배하는 자, Context 🚀

Go 언어 정복기: 요청의 생명주기를 지배하는 자, Context 🚀

동시성의 세계에서 길을 잃은 당신을 위한 필살 가이드

들어가며: "내 고루틴은 왜 멈추질 않는 거죠?" 😭

자, 여기 당신이 있습니다. Go 언어의 매력에 푹 빠져 멋진 웹 서버를 만들고 있죠. 짜릿한 동시성 처리, 가벼운 고루틴(goroutine)을 휙휙 날리며 수많은 요청을 동시에 처리하는 모습을 상상하니 벌써부터 어깨가 으쓱해집니다.

사용자 A가 이미지 업로드를 요청합니다. 당신의 서버는 고루틴을 하나 생성해서 열심히 이미지 처리를 시작하죠. 그런데... 사용자 A의 인내심이 바닥났나 봅니다. 업로드가 끝나기도 전에 브라우저 탭을 닫아버렸어요. 😱

사용자 입장에서는 요청이 '취소'된 것이지만, 당신의 서버는 어떨까요? 안타깝게도 서버는 그 사실을 까맣게 모릅니다. 이미 출발한 고루틴은 사용자가 떠났는지 어떤지 알 길이 없이, 혼자서 묵묵히 이미지 리사이징, 필터 적용, 데이터베이스 저장까지... 정해진 작업을 끝까지 수행합니다. CPU와 메모리는 하염없이 소모되고, 이미 아무도 기다리지 않는 결과를 만들기 위해 애쓰고 있는 거죠. 이런 '유령 작업'들이 쌓이면 어떻게 될까요? 상상만 해도 끔찍합니다. 서버는 점점 느려지고, 결국엔... 뻗어버릴지도 모릅니다.

이것이 바로 우리가 오늘 이야기할 주제의 핵심입니다. 바로 '요청의 생명주기 관리'. 사용자의 요청이 시작되고, 처리되고, 끝나는 전체 과정을 하나의 '생명주기'로 보고, 이 주기가 중간에 끝나야 할 때(사용자 취소, 타임아웃 등) 관련 작업들을 모두 함께 '우아하게' 중단시키는 기술이죠.

그리고 이 문제에 대한 Go의 대답이 바로 `context` 패키지입니다. `context`는 단순한 기능이 아니라, Go의 동시성 철학을 관통하는 매우 중요한 개념입니다. 오늘은 이 `context`라는 강력한 무기를 어떻게 사용해서 우리의 애플리케이션을 더 똑똑하고, 안정적이고, 효율적으로 만들 수 있는지 아주 깊고 재미있게 파헤쳐 볼 겁니다. 친구에게 설명하듯, 커피 한 잔 마시면서 편하게 따라와 보세요! ☕

1. Context, 너 정체가 뭐니? 🤔

`context`를 처음 들으면 뭔가 거창하고 추상적인 개념처럼 느껴질 수 있습니다. '문맥', '상황'... 사전을 찾아봐도 감이 잘 안 오죠. Go에서의 `context`는 아주 구체적인 역할을 가진 녀석입니다.

`context.Context`는 사실 인터페이스(interface)입니다. 즉, '이런이런 기능들을 제공해야 해!'라고 약속하는 일종의 명세서 같은 거죠. 이 명세서에는 크게 네 가지 핵심 기능이 정의되어 있습니다.

`context.Context` 인터페이스의 4대 천왕 1. `Done() <-chan struct{}`: "나 끝났어!"라고 알려주는 신호 채널. 이 채널에 신호가 오면, "아, 이 작업은 이제 그만해야 하는구나"라고 알아차릴 수 있습니다.
2. `Err() error`: 만약 작업이 끝났다면, '왜' 끝났는지 알려주는 친구입니다. 타임아웃 때문인지, 아니면 누군가 직접 취소했는지 그 이유를 담고 있죠.
3. `Deadline() (deadline time.Time, ok bool)`: "이 작업, 언제까지 끝내야 해?"라는 마감 기한을 알려줍니다. 마감 기한이 설정되어 있다면 `ok`는 `true`가 됩니다.
4. `Value(key any) any`: 요청과 관련된 데이터를 담아두는 작은 가방입니다. 요청 ID, 사용자 인증 정보처럼 여러 함수를 거치며 전달되어야 하는 값을 넣어 다닐 수 있죠.

이 네 가지 기능을 한마디로 요약하면 뭘까요?

"작업의 취소 신호, 마감 시간, 그리고 요청 범위의 데이터를 여러 함수와 고루틴에 걸쳐 안전하게 전파하는 표준적인 방법"

이라고 할 수 있습니다. 마치 달리기 경주에서 선수들에게 신호를 보내는 '심판'과도 같습니다. "출발!", "시간 초과야, 그만!", "부정 출발로 실격!" 같은 신호를 모든 선수(고루틴)에게 일관되게 전달하는 거죠.

1.1. `Done()` 채널: 멈춤의 미학 🚦

`context`의 핵심은 바로 이 `Done()` 메서드입니다. `<-chan struct{}` 라는 타입을 반환하는데, 처음 보면 조금 낯설 수 있죠.

  • `<-chan`: 읽기 전용(read-only) 채널이라는 뜻입니다. 우리는 이 채널로부터 신호를 받기만 할 수 있습니다.
  • `struct{}`: 비어있는 구조체입니다. 메모리를 전혀 차지하지 않기 때문에(0 바이트), '신호' 그 자체를 보내는 용도로 아주 안성맞춤입니다. 내용물은 필요 없고, "신호가 왔다"는 사실 자체가 중요하니까요.

`context`가 취소되면, Go 런타임은 이 `Done()` 채널을 닫아버립니다(close). Go에서 닫힌 채널을 읽으려고 하면 어떤 일이 벌어질까요? 기다림 없이 즉시 해당 타입의 제로 값(`struct{}`의 제로 값은 `{}`)을 반환합니다.

바로 이 특성을 이용해서 우리는 `select` 문과 함께 `context`의 취소 여부를 감지할 수 있습니다.


// 아주 긴 작업을 시뮬레이션하는 함수
func longRunningTask(ctx context.Context) {
    for {
        select {
        case <-ctx.Done(): // Done() 채널에서 신호가 오는지 감시!
            fmt.Println("작업 중단 요청 받음! 정리 작업을 시작합니다...")
            // 여기서 DB 커넥션 닫기, 임시 파일 삭제 등 정리 작업을 수행
            return // 함수 종료
        default:
            // 평소에는 이 부분이 실행됨
            fmt.Println("열심히 작업 중... 헥헥 💦")
            time.Sleep(1 * time.Second)
        }
    }
}

위 코드에서 `select` 문은 마치 갈림길과 같습니다. `ctx.Done()` 채널에 신호가 오면(채널이 닫히면) 첫 번째 `case`가 실행되어 함수가 종료됩니다. 신호가 오지 않으면 `default` 구문이 실행되어 계속 작업을 이어가죠. 이렇게 `context`는 강제로 작업을 멈추는 게 아니라, "이제 그만하는 게 좋겠어"라고 '알려주는' 역할을 합니다. 작업을 실제로 멈추고 정리하는 것은 개발자의 몫이죠. 이를 '협력적 취소(Cooperative Cancellation)'라고 부릅니다.

1.2. `Err()`: 왜 멈춰야 했나? 📜

`Done()` 채널을 통해 작업이 중단되어야 한다는 신호를 받았다면, `Err()` 메서드를 통해 그 이유를 확인할 수 있습니다.

  • `context.Canceled`: `cancel()` 함수를 통해 명시적으로 취소된 경우. 누군가 "이제 그만!"이라고 외친 상황입니다.
  • `context.DeadlineExceeded`: 데드라인이나 타임아웃이 지나서 자동으로 취소된 경우. "시간 다 됐어!"라는 상황이죠.

`context`가 아직 취소되지 않았다면, `Err()`는 `nil`을 반환합니다.


case <-ctx.Done():
    fmt.Println("작업 중단!")
    err := ctx.Err() // 왜 중단되었는지 이유를 확인
    if err == context.Canceled {
        fmt.Println("이유: 명시적인 취소 요청")
    } else if err == context.DeadlineExceeded {
        fmt.Println("이유: 시간 초과!")
    }
    return

이유를 아는 것은 매우 중요합니다. 로그를 남길 때, 사용자에게 에러 메시지를 보여줄 때 등 상황에 따라 다르게 대응할 수 있기 때문이죠.

1.3. `Deadline()`: 시간과의 싸움 ⏰

`Deadline()` 메서드는 이 `context`에 설정된 절대적인 마감 시간을 알려줍니다. `(time.Time, bool)` 두 개의 값을 반환하는데, 두 번째 `bool` 값이 `true`여야만 마감 시간이 설정된 것입니다.

보통 우리는 절대적인 시간보다는 "지금부터 5초 후에"와 같은 상대적인 시간을 더 많이 사용합니다. 그래서 `Deadline()`을 직접 사용하는 경우보다는, 뒤에서 배울 `context.WithTimeout`을 더 애용하게 될 겁니다. 하지만 내부적으로는 `WithTimeout`도 이 `Deadline`을 설정하는 방식으로 동작한다는 점을 알아두면 좋습니다.

1.4. `Value()`: 요청의 DNA를 품은 가방 🎒

`Value()`는 요청 처리의 시작부터 끝까지, 여러 함수를 거치면서도 계속 유지되어야 할 값을 전달하는 데 사용됩니다. 예를 들면 이런 것들이죠.

  • Trace ID: 분산 시스템에서 하나의 요청이 여러 마이크로서비스를 거칠 때, 이 요청을 추적하기 위한 고유 ID.
  • User ID: 로그인한 사용자의 ID. 모든 함수에서 이 사용자가 누구인지 알아야 할 때.
  • API Key: 요청에 사용된 인증 키 정보.

`Value()`는 `key`를 주면 `value`를 돌려주는 아주 간단한 원리입니다. 하지만 여기서 아주 아주 중요한 점이 있습니다.

`context.Value` 사용 시 절대 주의사항! `context.Value`는 함수의 '선택적 매개변수(optional parameter)'를 전달하는 용도로 사용해서는 절대 안 됩니다. 왜냐하면:

1. 정적 타입 검사의 이점을 잃게 됩니다. `key`와 `value`가 모두 `any`(Go 1.18 이전에는 `interface{}`) 타입이라 컴파일 시점에 타입 체크가 불가능합니다. 오타라도 나면 런타임에 패닉이 날 수도 있죠.
2. 함수의 시그니처가 불분명해집니다. 함수가 어떤 값들을 필요로 하는지 알려면 함수 내부 코드를 다 까봐야 합니다. 이건 좋은 API 설계가 아니죠.
3. 코드의 의존성이 숨겨집니다. `context`에 특정 값이 들어있을 거라고 암묵적으로 가정하게 되어, 코드를 이해하고 테스트하기 어렵게 만듭니다.

결론: `context.Value`는 요청의 흐름을 타는 '횡단 관심사(cross-cutting concerns)'에 해당하는 데이터에만 제한적으로 사용해야 합니다. 함수의 동작에 필수적인 파라미터는 반드시 명시적인 인자로 전달하세요!

또 다른 중요한 점은 `key`의 타입입니다. 문자열 같은 기본 타입을 `key`로 사용하면 다른 패키지에서 우연히 같은 `key`를 사용했을 때 값이 덮어씌워지는 충돌이 발생할 수 있습니다. 이를 방지하기 위해 보통 `key`로 사용할 비공개 커스텀 타입을 선언합니다.


// 키 충돌을 방지하기 위한 트릭
package main

import (
    "context"
    "fmt"
)

// key로 사용할 타입을 정의. 외부에서 접근 못하게 소문자로 시작.
type userKey string

func main() {
    // key를 생성
    const uKey userKey = "user"

    // context에 값을 저장
    ctx := context.WithValue(context.Background(), uKey, "Alice")

    // context에서 값을 읽어옴
    user := ctx.Value(uKey)
    fmt.Println("사용자:", user) // 출력: 사용자: Alice

    // 다른 패키지에서 "user"라는 문자열 키를 사용해도 충돌하지 않음!
    // 왜냐하면 타입이 다르기 때문 (string != userKey)
    otherValue := ctx.Value("user")
    fmt.Println("다른 값:", otherValue) // 출력: 다른 값: <nil>
}

2. Context 생성하기: 모든 것의 시작 🐣

자, `context`가 뭔지 대충 감을 잡았습니다. 그럼 이제 직접 만들어봐야겠죠? `context`는 레고 블록처럼 조립해서 사용합니다. 모든 `context`는 부모 `context`로부터 파생되어 '자식 `context`'를 만들어내는 계층 구조를 가집니다. 이 계층 구조의 최상위, 즉 모든 것의 시작점이 되는 두 개의 `context`가 있습니다.

2.1. 태초의 Context: `Background`와 `TODO`

`context.Background()`: 이름 그대로 '배경'입니다. 비어있는 `context`의 정석이죠.

  • 절대 취소되지 않습니다.
  • 어떤 값도 가지고 있지 않습니다.
  • 데드라인도 없습니다.

이 `Background` context는 보통 `main` 함수나 초기화 코드, 테스트 코드처럼 요청의 최상단에서 새로운 `context` 체인을 시작할 때 사용합니다. 모든 `context` 나무의 '뿌리'라고 생각하면 쉽습니다. 🌳

`context.TODO()`: 이 친구도 `Background`와 기능적으로는 완전히 동일합니다. 비어있고, 절대 취소되지 않죠. 그럼 왜 이름이 다를까요?

`TODO`는 이름 그대로 "나중에 할 일"이라는 의미를 가집니다. 즉, "지금 당장은 어떤 `context`를 써야 할지 명확하지 않지만, 나중에라도 꼭 적절한 `context`로 바꿔줘야 해!"라는 의도를 코드에 남기는 용도입니다.

예를 들어, 기존에 `context`를 받지 않던 함수를 리팩토링해서 `context`를 받도록 수정해야 할 때, 일단 `context.TODO()`를 넘겨서 컴파일 에러를 해결하고, 나중에 주변 코드까지 모두 수정해서 올바른 `context`를 전달하도록 계획할 수 있습니다. 정적 분석 툴들은 `context.TODO()`가 코드에 남아있으면 경고를 보내주기도 합니다.

`Background` vs `TODO` 언제 뭘 쓸까? - `context.Background()`: `context` 체인을 명확하게 시작하는 지점 (e.g., `main`, HTTP 요청 핸들러의 시작).
- `context.TODO()`: 어떤 `context`를 써야 할지 불분명하거나, 주변 코드가 아직 준비되지 않았을 때 임시로 사용하는 '자리 표시자'.

2.2. 파생 Context 만들기: `With` 시리즈 4인방

이제 진짜 마법이 시작됩니다. `Background`나 `TODO` 같은 뿌리 `context`에 새로운 기능(취소, 데드라인, 값)을 추가해서 새로운 자식 `context`를 만드는 함수들이 있습니다. 바로 `WithCancel`, `WithDeadline`, `WithTimeout`, `WithValue` 입니다.

이 함수들은 모두 `(parent Context)`를 첫 번째 인자로 받아서, 새로운 `(Context, CancelFunc)` 또는 `Context`를 반환합니다.

`context.WithCancel(parent)`: 수동 취소 스위치

가장 기본적이고 중요한 파생 함수입니다. 이 함수는 부모 `context`를 기반으로, 언제든 원할 때 취소할 수 있는 기능을 가진 자식 `context`를 만듭니다.


ctx, cancel := context.WithCancel(context.Background())

여기서 `cancel`은 `func()` 타입의 함수입니다. 이 `cancel()` 함수를 호출하는 순간, `ctx`는 취소됩니다. 그리고 `ctx`로부터 파생된 모든 자손 `context`들도 연쇄적으로 함께 취소됩니다. 이것이 `context` 전파의 핵심입니다.

아주 중요한 점은, `cancel` 함수는 반드시 호출되어야 한다는 것입니다. 설령 작업이 성공적으로 끝나서 취소할 필요가 없더라도 말이죠. 왜냐하면 `cancel` 함수를 호출해야 `context`가 사용하던 관련 리소스들이 정리되기 때문입니다. 호출하지 않으면 메모리 누수(leak)가 발생할 수 있습니다!

그래서 보통 `defer`와 함께 사용하는 것이黄金律(golden rule)입니다.


func main() {
    // 취소 기능이 있는 context 생성
    ctx, cancel := context.WithCancel(context.Background())
    
    // main 함수가 끝나기 직전에 반드시 cancel()이 호출되도록 보장!
    defer cancel()

    go func(ctx context.Context) {
        for {
            select {
            case <-ctx.Done():
                fmt.Println("고루틴: 작업 중단 신호 감지!")
                return
            default:
                fmt.Println("고루틴: 작업 중...")
                time.Sleep(500 * time.Millisecond)
            }
        }
    }(ctx)

    fmt.Println("메인: 3초 후에 작업을 취소합니다.")
    time.Sleep(3 * time.Second)
    
    cancel() // 여기서 취소 신호를 보냄!

    // 고루틴이 종료될 시간을 조금 줌
    time.Sleep(1 * time.Second) 
    fmt.Println("메인: 프로그램 종료.")
}

위 예제에서 `main` 함수가 `cancel()`을 호출하자마자, 별도의 고루틴에서 돌고 있던 `for` 루프는 `<-ctx.Done()` 케이스를 타게 되고, "작업 중단 신호 감지!" 메시지를 출력한 뒤 안전하게 종료됩니다.

`context.WithTimeout(parent, duration)` & `context.WithDeadline(parent, time)`: 자동 폭파 타이머

이 두 함수는 `WithCancel`에 시간제한 기능을 추가한 버전입니다.

  • `WithTimeout`: "지금부터 `duration` 시간 후에 자동으로 취소해줘." (상대 시간)
  • `WithDeadline`: "특정 `time` 시각이 되면 자동으로 취소해줘." (절대 시간)

실무에서는 특정 시간보다는 "이 작업은 3초 안에 끝나야 해" 와 같이 상대적인 시간을 사용하는 `WithTimeout`이 훨씬 더 자주 쓰입니다.

이 함수들도 `(Context, CancelFunc)`를 반환합니다. 여기서 `cancel` 함수의 역할은 두 가지입니다.

  1. 타임아웃이 되기 전에 작업을 성공적으로 마쳤을 때, `cancel()`을 호출해서 `context`에 할당된 타이머 리소스를 즉시 정리하는 역할. (메모리 누수 방지)
  2. 타임아웃을 기다리지 않고, 수동으로 작업을 즉시 취소하고 싶을 때 사용하는 역할.

결론은? `WithTimeout`이나 `WithDeadline`을 써도 `defer cancel()`은 무조건 습관처럼 따라와야 합니다.


func slowOperationWithTimeout() {
    // 2초의 타임아웃을 가진 context 생성
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel() // 성공하든 실패하든 리소스 정리는 필수!

    // 오래 걸리는 작업을 고루틴으로 실행
    ch := make(chan bool)
    go func() {
        // 이 작업은 3초가 걸린다고 가정
        time.Sleep(3 * time.Second)
        ch <- true
    }()

    // 결과가 오거나, context가 취소되거나...
    select {
    case <-ch:
        fmt.Println("오! 작업이 시간 안에 끝났습니다! (이 메시지는 볼 수 없을 겁니다)")
    case <-ctx.Done():
        // 2초가 지나면 ctx.Done() 채널이 닫히면서 이쪽으로 빠짐
        fmt.Println("작업 시간 초과! ⏰")
        fmt.Println("에러 원인:", ctx.Err()) // context.DeadlineExceeded 출력
    }
}

이 코드를 실행하면, `slowOperation`이 3초가 걸리기 때문에 2초짜리 타임아웃에 걸려 "작업 시간 초과!" 메시지가 출력될 겁니다. 외부 API를 호출하거나 DB 쿼리를 날릴 때, 응답이 무한정 길어지는 것을 방지하기 위해 거의 필수적으로 사용됩니다.

`WithValue(parent, key, value)`: 데이터 전달자

앞서 설명했듯이, 요청 범위의 데이터를 전달할 때 사용합니다. 이 함수는 다른 `With` 함수들과는 다르게 `cancel` 함수를 반환하지 않습니다. 왜냐하면 값을 추가하는 것은 취소 동작과는 관련이 없기 때문이죠.


type key string
const requestIDKey key = "requestID"

func processRequest(ctx context.Context) {
    // context에서 requestID를 꺼내서 로그에 남김
    reqID, ok := ctx.Value(requestIDKey).(string)
    if !ok {
        reqID = "unknown"
    }
    fmt.Printf("[%s] 요청 처리 시작...\n", reqID)
    
    // ... 실제 처리 로직 ...
    
    fmt.Printf("[%s] 요청 처리 완료.\n", reqID)
}

func main() {
    // Background context에 requestID 값을 추가
    ctx := context.WithValue(context.Background(), requestIDKey, "trace-xyz-123")
    
    processRequest(ctx)
}

`main` 함수에서 `context`에 `requestID`를 심어두니, `processRequest` 함수에서는 인자로 받은 `ctx`에서 그 값을 꺼내 쓸 수 있습니다. 만약 `processRequest`가 또 다른 함수를 호출하더라도, 이 `ctx`를 그대로 넘겨주기만 하면 그곳에서도 `requestID`를 꺼내 쓸 수 있죠. 이것이 바로 `context`를 통한 데이터 전파입니다.

3. Context 트리와 전파: 취소는 연쇄 폭발이다! 💥

`context`의 가장 강력하고 아름다운 특징은 바로 '전파(Propagation)'입니다. `With` 함수들을 통해 자식 `context`를 만들면, 부모와 자식 간에 연결고리가 생깁니다. 이 연결고리들이 모여 하나의 거대한 트리 구조를 형성하죠.

Context 트리와 취소 전파 Background() Root Context ctxA, cancelA := WithCancel(root) ctxB, cancelB := WithTimeout(root, 5s) ctxA1 := WithValue(ctxA, "key", "val") ctxA2, cancelA2 := WithTimeout(ctxA, 2s) ctxB1, cancelB1 := WithCancel(ctxB) cancelA() 호출! `cancelA()`가 호출되면, ctxA, ctxA1, ctxA2가 모두 취소됩니다. 하지만 ctxB와 ctxB1은 영향을 받지 않습니다.

이 트리 구조의 규칙은 아주 간단하고 강력합니다.

"부모 `context`가 취소되면, 그 자식 `context`들은 모두 함께, 즉시, 자동으로 취소된다."

하지만 그 역은 성립하지 않습니다. 자식 `context`가 취소된다고 해서 부모나 다른 형제 `context`가 영향을 받지는 않습니다. 위 그림에서 `cancelA()`를 호출하면 `ctxA`와 그 자식들인 `ctxA1`, `ctxA2`는 모두 취소되지만, 형제인 `ctxB`나 부모인 `root`는 멀쩡합니다.

이것이 바로 요청 생명주기 관리의 핵심 원리입니다. 웹 서버를 예로 들어볼까요?

  1. 사용자로부터 HTTP 요청이 들어옵니다. Go의 `net/http` 서버는 이 요청을 위한 '뿌리 `context`'를 하나 만들어줍니다 (`r.Context()`). 이 `context`는 사용자가 연결을 끊으면 자동으로 취소됩니다.
  2. 요청 핸들러 함수는 이 `context`를 받습니다. 이제 데이터베이스에서 사용자 정보를 가져와야 합니다. DB 쿼리는 최대 1초를 넘기면 안 될 것 같습니다.
  3. 핸들러는 `ctxDB, cancel := context.WithTimeout(r.Context(), 1*time.Second)` 코드로 자식 `context`를 만듭니다. 그리고 이 `ctxDB`를 DB 조회 함수에 넘겨줍니다.
  4. 동시에, 외부 결제 API도 호출해야 합니다. 이 API는 최대 3초까지 기다려줄 수 있습니다.
  5. 핸들러는 `ctxPayment, cancel2 := context.WithTimeout(r.Context(), 3*time.Second)` 코드로 또 다른 자식 `context`를 만들고, 결제 API 호출 함수에 넘겨줍니다.

이제 어떤 일이 벌어질 수 있을까요?

  • 시나리오 1 (정상): DB 조회도 1초 안에, 결제 API 호출도 3초 안에 성공적으로 끝납니다. 모든 것이 해피엔딩. 🥳
  • 시나리오 2 (DB 타임아웃): DB 조회가 1초를 넘깁니다. `ctxDB`가 타임아웃으로 취소되고, DB 조회 함수는 에러를 반환하고 즉시 중단됩니다. 하지만 `ctxPayment`는 아직 유효하므로 결제 API 호출은 계속 진행될 수 있습니다 (물론 DB 조회 실패 시 결제를 진행할지는 비즈니스 로직에 따라 다릅니다).
  • 시나리오 3 (사용자 취소): 모든 작업이 한창 진행 중인데, 사용자가 브라우저를 닫아버립니다. 그러면 최상위 부모인 `r.Context()`가 취소됩니다. 이 신호가 연쇄적으로 전파되어, `ctxDB`와 `ctxPayment`도 즉시 함께 취소됩니다. DB 조회 함수와 결제 API 호출 함수는 모두 `<-ctx.Done()` 신호를 받고 작업을 중단하겠죠. 서버 리소스 낭비를 막았습니다! 🛡️

이처럼 `context`를 함수의 첫 번째 인자로 계속해서 전달하는 것만으로도, 우리는 전체 작업 체인에 걸쳐 '취소'라는 일관된 정책을 아주 쉽게 전파할 수 있습니다.


// main -> handler -> service -> repository로 이어지는 호출 체인
func main() {
    // 실제로는 http.ListenAndServe 등으로 서버를 시작하겠죠.
    // 여기서는 시뮬레이션을 위해 Background context로 시작.
    rootCtx := context.Background()
    requestHandler(rootCtx)
}

// 1. 요청 핸들러: 전체 작업의 타임아웃을 3초로 설정
func requestHandler(ctx context.Context) {
    // 이 요청은 3초 안에 끝나야 한다!
    reqCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()

    fmt.Println("핸들러: 서비스 레이어 호출")
    err := businessService(reqCtx)
    if err != nil {
        fmt.Printf("핸들러: 에러 발생! %v\n", err)
    } else {
        fmt.Println("핸들러: 작업 성공!")
    }
}

// 2. 서비스 레이어: 비즈니스 로직 처리
func businessService(ctx context.Context) error {
    fmt.Println("서비스: DB 작업 호출")
    // DB 작업은 5초가 걸린다고 가정 (핸들러의 타임아웃 3초보다 김)
    err := databaseOperation(ctx, 5*time.Second)
    if err != nil {
        return fmt.Errorf("서비스: DB 작업 실패: %w", err)
    }
    
    // ... 다른 로직 ...
    return nil
}

// 3. 리포지토리 레이어: 실제 DB 작업 (시뮬레이션)
func databaseOperation(ctx context.Context, duration time.Duration) error {
    fmt.Println("DB: 작업 시작...")
    select {
    case <-time.After(duration): // 작업이 실제로 걸리는 시간
        fmt.Println("DB: 작업 완료!")
        return nil
    case <-ctx.Done(): // 부모로부터 취소 신호가 오는지 감시
        fmt.Println("DB: 작업이 외부로부터 취소됨!")
        return ctx.Err() // 왜 취소됐는지 이유를 반환
    }
}

// 실행 결과:
// 핸들러: 서비스 레이어 호출
// 서비스: DB 작업 호출
// DB: 작업 시작...
// (3초 후)
// DB: 작업이 외부로부터 취소됨!
// 핸들러: 에러 발생! 서비스: DB 작업 실패: context deadline exceeded

보세요! `databaseOperation` 함수는 5초가 걸리는 작업이었지만, 그 부모의 부모인 `requestHandler`에서 설정한 3초 타임아웃 때문에 중간에 깔끔하게 중단되었습니다. 각 함수는 그저 자신에게 주어진 `context`의 `Done()` 채널만 바라보면 됩니다. 상위에서 어떤 타임아웃을 걸었는지, 사용자가 취소했는지 일일이 신경 쓸 필요가 없는 거죠. 이것이 바로 관심사의 분리(Separation of Concerns)이며, `context`가 Go 코드를 얼마나 깔끔하게 만드는지 보여주는 좋은 예입니다.

4. 실전! Context 활용 백서 📖

이론은 충분히 익혔으니, 이제 실제 현장에서 `context`가 어떻게 활약하는지 구체적인 시나리오를 통해 알아보겠습니다. 이 파트만 잘 이해해도 "아, Go 좀 하는구나!" 소리를 들을 수 있을 겁니다. 😉

4.1. HTTP 서버: 모든 것의 시작점

Go의 `net/http` 패키지는 `context`를 아주 모범적으로 활용합니다. `http.Server`는 들어오는 모든 요청에 대해 `context`를 생성해서 `http.Request` 구조체 안에 넣어줍니다.

  • 이 `context`는 클라이언트의 연결이 끊어지면 자동으로 취소됩니다. (가장 중요한 기능!)
  • `http.Server`의 `ReadTimeout`, `WriteTimeout` 등과도 연동됩니다.

따라서 HTTP 핸들러 함수 안에서는 `r.Context()`를 호출해서 이 `context`를 꺼내 쓰는 것이 모든 `context` 전파의 시작점이 됩니다.


func myHandler(w http.ResponseWriter, r *http.Request) {
    // 1. 요청에 내장된 context를 꺼낸다. 이것이 이 요청 생명주기의 뿌리!
    ctx := r.Context()

    // 2. 이 요청 처리 전체에 대한 타임아웃을 5초로 설정한다.
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()

    // 3. 오래 걸릴 수 있는 작업을 고루틴으로 실행하고, 결과를 채널로 받는다.
    resultChan := make(chan string)
    errChan := make(chan error)

    go func() {
        // 외부 API 호출이나 DB 쿼리 등
        result, err := someLongRunningProcess(ctx)
        if err != nil {
            errChan <- err
            return
        }
        resultChan <- result
    }()

    // 4. 작업 결과가 오거나, 타임아웃이 되거나...
    select {
    case result := <-resultChan:
        fmt.Fprintf(w, "성공! 결과: %s", result)
    case err := <-errChan:
        // someLongRunningProcess 내부에서 context 취소로 인한 에러가 발생했을 수 있다.
        http.Error(w, "작업 중 에러 발생: "+err.Error(), http.StatusInternalServerError)
    case <-ctx.Done():
        // 5초 타임아웃이 되거나, 클라이언트가 연결을 끊었을 때 이쪽으로 온다.
        log.Println("요청이 취소되었습니다:", ctx.Err())
        http.Error(w, "요청 시간 초과 또는 클라이언트 연결 끊김", http.StatusGatewayTimeout)
    }
}

// 이 함수는 반드시 context를 인자로 받아야 한다.
func someLongRunningProcess(ctx context.Context) (string, error) {
    // ... 이 안에서도 ctx.Done()을 select 해서 취소에 대응해야 함 ...
    // 예시: 2초짜리 작업
    select {
    case <-time.After(2 * time.Second):
        return "작업 완료", nil
    case <-ctx.Done():
        return "", ctx.Err()
    }
}

만약 `myHandler`가 실행되는 도중에 사용자가 브라우저를 새로고침하거나 탭을 닫으면, `r.Context()`가 취소되고, 그 자식인 `ctx`도 취소되어 `<-ctx.Done()` 케이스가 실행됩니다. `someLongRunningProcess` 내부에서도 `ctx.Done()`을 감지하고 즉시 중단하겠죠. 완벽한 리소스 관리입니다.

4.2. 데이터베이스 작업: 무한 쿼리의 악몽을 끝내자

복잡한 `JOIN`이나 `FULL SCAN`이 걸리는 쿼리는 예기치 않게 아주 오래 실행될 수 있습니다. `context`가 없다면, 요청이 이미 타임아웃 되었는데도 DB는 하염없이 쿼리를 계속 돌리고 있겠죠.

다행히 Go의 표준 `database/sql` 패키지는 `context`를 완벽하게 지원합니다. `Query`, `Exec`, `Begin` 등 대부분의 메서드에 `...Context` 버전이 함께 제공됩니다. (e.g., `db.QueryContext`, `db.ExecContext`, `db.BeginTx`)


func GetUserFromDB(ctx context.Context, db *sql.DB, userID int) (*User, error) {
    // DB 작업만을 위한 타임아웃을 2초로 별도 설정할 수 있다.
    // 부모 ctx가 먼저 취소되면 이 타임아웃과 상관없이 즉시 취소된다.
    queryCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()

    var user User
    // QueryRow가 아닌 QueryRowContext를 사용!
    err := db.QueryRowContext(queryCtx, "SELECT id, name, email FROM users WHERE id = ?", userID).
        Scan(&user.ID, &user.Name, &user.Email)

    if err != nil {
        // 여기서 에러를 확인해보면, 타임아웃 시 context.DeadlineExceeded가 포함되어 있을 것이다.
        return nil, err
    }

    return &user, nil
}

이제 `GetUserFromDB` 함수는 상위 요청이 취소되거나, 혹은 자체적으로 설정한 2초의 쿼리 타임아웃이 지나면 즉시 실행을 중단하고 에러를 반환합니다. DB 드라이버는 `context`가 취소되면 서버에 쿼리 취소 명령을 보내려고 시도합니다 (DB 종류나 드라이버 구현에 따라 동작은 다를 수 있음).

4.3. 마이크로서비스 호출: 분산 시스템의 생명줄

현대의 많은 시스템은 여러 마이크로서비스가 서로 통신하는 구조로 되어 있습니다. 서비스 A가 서비스 B를 호출하고, 서비스 B는 또 서비스 C를 호출하는 식이죠.

이때 `context`는 두 가지 중요한 역할을 합니다.

  1. 데드라인 전파 (Deadline Propagation): 사용자 요청의 전체 타임아웃이 5초인데, 서비스 A에서 1초를 썼다면, 서비스 B에게는 "너는 이제 4초 안에 응답해야 해!"라고 알려줄 수 있습니다. 이렇게 남은 시간을 계속해서 다음 서비스로 전파하면 전체 시스템의 응답 시간을 예측 가능하게 관리할 수 있습니다.
  2. 메타데이터 전파: `context.Value`에 담긴 Trace ID 같은 추적 정보를 HTTP 헤더나 gRPC 메타데이터에 실어서 다음 서비스로 전달합니다. 이렇게 하면 분산 추적 시스템(जैसे Jaeger, Zipkin)에서 전체 요청의 흐름을 한눈에 파악할 수 있습니다.

// 서비스 A의 코드
func callServiceB(ctx context.Context) (string, error) {
    // 서비스 B 호출을 위한 타임아웃 설정
    // 부모 ctx의 남은 데드라인과 3초 중 더 짧은 쪽으로 자동 설정됨
    callCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()

    // HTTP 요청 객체 생성
    req, err := http.NewRequestWithContext(callCtx, "GET", "http://service-b/data", nil)
    if err != nil {
        return "", err
    }

    // context에 담긴 Trace ID를 헤더에 추가
    if traceID, ok := ctx.Value(traceIDKey).(string); ok {
        req.Header.Set("X-Trace-ID", traceID)
    }

    // API 호출
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        // callCtx가 타임아웃되면 여기서 에러가 발생
        return "", err
    }
    defer resp.Body.Close()

    // ... 응답 처리 ...
    body, _ := io.ReadAll(resp.Body)
    return string(body), nil
}

`http.NewRequestWithContext` 함수를 사용하는 것이 핵심입니다. 이 함수는 `context`가 취소되면 진행 중인 HTTP 요청을 중단시키는 역할을 합니다. gRPC 같은 최신 RPC 프레임워크들은 `context`를 기본적으로 지원하여 이런 데드라인 및 메타데이터 전파를 훨씬 더 쉽고 세련되게 처리해줍니다.

4.4. 우아한 종료 (Graceful Shutdown): 끝날 때도 품위있게

서버를 종료해야 할 때 (배포, 점검 등), 실행 중이던 요청들을 무시하고 그냥 꺼버리면 어떻게 될까요? 사용자는 에러 화면을 보게 되고, 데이터 정합성이 깨질 수도 있습니다. '우아한 종료'는 새로운 요청은 더 이상 받지 않되, 현재 처리 중인 요청들은 모두 끝날 때까지 기다려준 뒤 종료하는 것을 의미합니다.

`context`는 이 우아한 종료를 구현하는 데에도 아주 멋지게 사용됩니다.


func main() {
    server := &http.Server{Addr: ":8080", Handler: myMux}

    // 서버를 별도의 고루틴에서 실행
    go func() {
        log.Println("서버 시작!")
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("서버 시작 실패: %v", err)
        }
    }()

    // 종료 신호를 기다릴 채널
    quit := make(chan os.Signal, 1)
    // Ctrl+C (SIGINT) 나 kill 명령어 (SIGTERM) 신호를 받도록 설정
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    
    // 신호가 올 때까지 여기서 블로킹
    <-quit
    log.Println("서버 종료 신호 받음...")

    // 우아한 종료를 위한 context 생성. 5초의 타임아웃을 줌.
    // 5초 안에 기존 요청 처리가 안 끝나면 강제 종료.
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    // 서버의 Shutdown 메서드 호출
    if err := server.Shutdown(ctx); err != nil {
        log.Fatal("서버 강제 종료: ", err)
    }

    log.Println("서버가 우아하게 종료되었습니다.")
}

이 코드는 OS로부터 종료 신호를 받으면, `server.Shutdown(ctx)`를 호출합니다. 이 `Shutdown` 함수는 새로운 요청을 막고, 진행 중인 모든 요청의 핸들러들이 반환될 때까지 기다립니다. 하지만 무한정 기다릴 수는 없으니, 5초의 타임아웃을 가진 `context`를 넘겨주는 거죠. 만약 5초가 지나도 끝나지 않는 요청이 있다면, `Shutdown`은 에러를 반환하고 서버는 강제로 종료됩니다.

5. Context 사용의 정석: Do's and Don'ts ✅❌

`context`는 강력한 도구이지만, 잘못 사용하면 오히려 코드를 복잡하게 만들 수 있습니다. Go 커뮤니티에서 수많은 논의를 거쳐 정립된 모범 사례들을 꼭 기억해두세요. 당신의 코드를 한 단계 더 성숙하게 만들어 줄 겁니다. 이런 고급 지식들은 혼자 깨우치기 어려울 수 있는데, 그럴 땐 **재능넷** 같은 플랫폼에서 숙련된 Go 개발자에게 코드 리뷰나 멘토링을 받아보는 것도 좋은 방법입니다.

반드시 지켜야 할 것 (Do's) 1. `Context`는 함수의 첫 번째 인자로 전달하세요. 이름은 관례적으로 `ctx`를 사용합니다. `func DoSomething(ctx context.Context, arg1 string, arg2 int)` 와 같이요. 이건 거의 모든 Go 프로젝트가 따르는 불문율입니다.
2. `defer cancel()`을 잊지 마세요. `context.WithCancel`, `WithTimeout`, `WithDeadline`으로 `context`를 만들었다면, 그 함수가 끝나기 전에 `cancel` 함수가 반드시 호출되도록 `defer`를 사용하세요. 리소스 누수를 막는 가장 중요한 습관입니다.
3. `context` 체인을 끊지 마세요. 상위 함수에서 `context`를 받았다면, 하위 함수를 호출할 때 그 `context`를 기반으로 새로운 `context`를 만들거나, 혹은 그대로 전달해야 합니다. 중간에 `context.Background()`나 `context.TODO()`로 새로운 체인을 시작하면 상위의 취소 신호가 전파되지 않습니다.
4. 취소는 협력적이라는 사실을 이해하세요. `context`를 전달하는 것만으로 작업이 마법처럼 멈추지 않습니다. `context`를 받은 쪽에서 `select { case <-ctx.Done(): ... }` 구문을 통해 능동적으로 취소 신호를 확인하고 작업을 중단하는 코드를 작성해야 합니다.
절대 피해야 할 것 (Don'ts) 1. `Context`를 구조체(struct)의 필드로 포함시키지 마세요. `Context`는 요청의 생명주기를 따르며 스택을 따라 흘러 내려가야 하는 데이터입니다. 구조체에 포함시키면 `context`의 생명주기가 불분명해지고, 다른 요청의 `context`와 섞이는 등 예측 불가능한 문제를 일으킬 수 있습니다. 항상 명시적으로 함수 인자로 전달하세요.
2. `nil` `Context`를 전달하지 마세요. 함수가 `context`를 인자로 받는다면, 절대 `nil`을 넘기면 안 됩니다. 대부분의 경우 패닉을 유발할 겁니다. 어떤 `context`를 써야 할지 정말 모르겠다면, `context.TODO()`를 사용해서 "나중에 수정해야 할 부분"임을 명시하세요.
3. `context.Value`를 함수에 옵션을 전달하는 용도로 남용하지 마세요. 앞서 강조했듯이, 이는 안티패턴입니다. 함수의 동작에 필요한 값들은 명시적인 파라미터로 전달하는 것이 코드를 훨씬 명확하고 테스트하기 쉽게 만듭니다. `context.Value`는 오직 요청 범위의 메타데이터를 위한 것입니다.
4. 다른 요청의 `context`를 다른 요청을 위해 사용하지 마세요. `context`는 이름 그대로 하나의 '문맥'에 종속됩니다. A 요청을 위해 만들어진 `context`를 B 요청을 처리하는 고루틴에 넘기면, A 요청이 취소될 때 뜬금없이 B 요청의 작업이 중단되는 대참사가 발생할 수 있습니다.

이 원칙들만 잘 지켜도, 당신은 `context`를 올바르게 사용하는 상위 10%의 Go 개발자가 될 수 있습니다. 코드는 단순히 동작하는 것을 넘어, 다른 사람이 읽고 이해하기 쉬워야 하며, `context`의 올바른 사용은 그 가독성과 안정성에 크게 기여합니다.

마치며: 동시성 프로그래밍의 나침반 🧭

오늘 우리는 Go의 `context` 패키지에 대해 정말 깊이 있게 탐험했습니다. 처음에는 그저 '취소'를 위한 도구 정도로 생각했을지 모르지만, 이제는 `context`가 단순한 기능을 넘어 Go의 동시성 모델을 떠받치는 철학적인 기둥이라는 것을 느끼셨을 겁니다.

`context`는 흩어져 있는 수많은 고루틴들에게 일관된 '문맥'을 부여합니다. "우리는 지금 어떤 요청을 처리하고 있는가?", "언제까지 이 일을 마쳐야 하는가?", "이 일이 중간에 취소된다면 모두 함께 멈춰야 한다"는 약속을 코드 전체에 걸쳐 전파하는 나침반과도 같죠.

이 나침반을 손에 쥔 당신은 이제 더 이상 유령처럼 떠도는 고루틴이나 무한정 대기하는 요청 때문에 밤잠을 설치지 않아도 됩니다. 안정적이고, 예측 가능하며, 리소스를 효율적으로 사용하는 견고한 애플리케이션을 만들 수 있는 힘을 얻었습니다.

물론 `context`를 모든 곳에 완벽하게 적용하는 것은 처음에는 조금 어색하고 번거롭게 느껴질 수 있습니다. 하지만 꾸준히 연습하고, 오늘 배운 모범 사례들을 코드에 녹여내다 보면 어느새 `context`를 자유자재로 다루는 자신을 발견하게 될 겁니다. Go 개발자로서의 여정에서 `context`는 당신을 더 높은 수준으로 이끌어 줄 든든한 동반자가 되어줄 것이라 확신합니다.

혹시라도 더 깊은 지식이나 실제 프로젝트 적용에 대한 도움이 필요하다면, 주저하지 말고 **재능넷**과 같은 전문가 커뮤니티의 문을 두드려보세요. 당신의 성장을 응원합니다! 🚀

댓글 작성

이 글에 대한 여러분의 생각을 들려주세요

댓글 0
댓글을 불러오는 중입니다.

아직 댓글이 없습니다.