고루틴과 채널: Go의 동시성 패턴

동시성을 사용하면 여러 작업을 서로 독립적으로 처리할 수 있습니다. 고루틴은 여러 작업을 독립적으로 처리하는 간단한 방법입니다. 이 게시물에서 우리는 채널과 동기화 패키지를 활용하여 Go의 다양한 동시성 패턴을 탐색하고 파일을 허용하는 http 핸들러를 점진적으로 향상시킵니다.

설정

동시성 패턴을 살펴보기 전에 먼저 준비를 해보겠습니다. 양식을 통해 여러 파일을 받아들이고 어떤 방식으로든 파일을 처리하는 HTTP 처리기가 있다고 가정해 보세요.

func processFile(file multipart.File) {
   // do something with the file
   fmt.Println("Processing file...")
   time.Sleep(100 * time.Millisecond) // Simulating file processing time
}
func UploadHandler(w http.ResponseWriter, r *http.Request) {
   // limit to 10mb 
   if err := r.ParseMultipartForm(10 << 20); err != nil {
       http.Error(w, "Unable to parse form", http.StatusBadRequest)
       return 
   }
   // iterate through all files and process them sequentially 
   for _, file := range r.MultipartForm.File["files"] {
       f, err := file.Open()
       if err != nil {
          http.Error(w, "Unable to read file", http.StatusInternalServerError)
          return
       }
       processFile(f)
       f.Close()
   }
}

위의 예에서는 양식에서 파일을 받아 순차적으로 처리합니다. 10개의 파일이 업로드되면 프로세스를 완료하고 클라이언트에 응답을 보내는 데 1초가 걸립니다.
많은 파일을 처리할 때 병목 현상이 발생할 수 있지만 Go의 동시성 지원을 통해 이 문제를 쉽게 해결할 수 있습니다.

대기 그룹

이 문제를 해결하기 위해 파일을 동시에 처리할 수 있습니다. 새로운 고루틴을 생성하려면 함수 호출 앞에 go 키워드를 붙일 수 있습니다. 프로세스파일(f)로 이동합니다. 그러나 고루틴은 차단하지 않기 때문에 프로세스가 완료되기 전에 핸들러가 반환되어 파일이 처리되지 않은 상태로 남거나 잘못된 상태를 반환할 수 있습니다. 모든 파일의 처리를 기다리려면 sync.WaitGroup을 활용할 수 있습니다.
WaitGroup은 여러 고루틴이 완료될 때까지 기다립니다. 우리가 생성한 각 고루틴에 대해 추가로 WaitGroup의 카운터를 늘려야 합니다. 이는 Add 기능을 사용하여 수행할 수 있습니다. 고루틴이 완료되면 카운터가 1씩 감소하도록 Done을 ​​호출해야 합니다. 함수에서 복귀하기 전에 WaitGroup의 카운터가 0이 될 때까지 차단하는 Wait를 호출해야 합니다.

func UploadHandler(w http.ResponseWriter, r *http.Request) {
   if err := r.ParseMultipartForm(10 << 20); err != nil {
       http.Error(w, "Unable to parse form", http.StatusBadRequest)
       return
   }

   // create WaitGroup 
   var wg sync.WaitGroup 
   for _, file := range r.MultipartForm.File["files"] {
       f, err := file.Open()
       if err != nil {
          http.Error(w, "Unable to read file", http.StatusInternalServerError)
          return
       }

       wg.Add(1) // Add goroutine to the WaitGroup by incrementing the WaitGroup counter, this should be called before starting a goroutine
       // Process file concurrently
       go func(file multipart.File) {
           defer wg.Done() // decrement the counter by calling Done, utilize defer to guarantee that Done is called. 
           defer file.Close()
           processFile(f)
       }(f)
   }

   // Wait for all goroutines to complete
   wg.Wait()
   fmt.Fprintln(w, "All files processed successfully!")
}

이제 업로드된 파일마다 새로운 고루틴이 생성되어 시스템에 부담을 줄 수 있습니다. 한 가지 해결책은 생성되는 고루틴 수를 제한하는 것입니다.

세마포어로 동시성 제한

세마포어는 여러 스레드 또는 이 경우 고루틴에서 공통 리소스에 대한 액세스를 제어하는 ​​데 사용할 수 있는 변수일 뿐입니다.

Go에서는 버퍼링된 채널을 활용하여 세마포어를 구현할 수 있습니다.

채널

구현을 시작하기 전에 채널이 무엇인지, 버퍼링된 채널과 버퍼링되지 않은 채널의 차이점을 살펴보겠습니다.

채널은 Go 루틴 사이에서 안전하게 통신하기 위해 데이터를 주고받을 수 있는 파이프입니다.
채널은 make 기능으로 생성되어야 합니다.

func processFile(file multipart.File) {
   // do something with the file
   fmt.Println("Processing file...")
   time.Sleep(100 * time.Millisecond) // Simulating file processing time
}
func UploadHandler(w http.ResponseWriter, r *http.Request) {
   // limit to 10mb 
   if err := r.ParseMultipartForm(10 << 20); err != nil {
       http.Error(w, "Unable to parse form", http.StatusBadRequest)
       return 
   }
   // iterate through all files and process them sequentially 
   for _, file := range r.MultipartForm.File["files"] {
       f, err := file.Open()
       if err != nil {
          http.Error(w, "Unable to read file", http.StatusInternalServerError)
          return
       }
       processFile(f)
       f.Close()
   }
}

채널에는 채널에서 보내거나 읽는 데 사용되는 특수 연산자 <-가 있습니다.
채널 ch

애니메이션은 버퍼링되지 않은 채널을 통해 값 1을 보내는 생산자와 채널에서 읽는 소비자를 시각화합니다.

생산자가 소비자가 처리할 수 있는 것보다 더 빠르게 이벤트를 보낼 수 있는 경우 버퍼 채널을 활용하여 버퍼가 가득 찰 때까지 생산자를 차단하지 않고 여러 메시지를 대기열에 추가할 수 있습니다. 동시에 소비자는 원하는 속도로 메시지를 처리할 수 있습니다.

func UploadHandler(w http.ResponseWriter, r *http.Request) {
   if err := r.ParseMultipartForm(10 << 20); err != nil {
       http.Error(w, "Unable to parse form", http.StatusBadRequest)
       return
   }

   // create WaitGroup 
   var wg sync.WaitGroup 
   for _, file := range r.MultipartForm.File["files"] {
       f, err := file.Open()
       if err != nil {
          http.Error(w, "Unable to read file", http.StatusInternalServerError)
          return
       }

       wg.Add(1) // Add goroutine to the WaitGroup by incrementing the WaitGroup counter, this should be called before starting a goroutine
       // Process file concurrently
       go func(file multipart.File) {
           defer wg.Done() // decrement the counter by calling Done, utilize defer to guarantee that Done is called. 
           defer file.Close()
           processFile(f)
       }(f)
   }

   // Wait for all goroutines to complete
   wg.Wait()
   fmt.Fprintln(w, "All files processed successfully!")
}

이 예에서 생산자는 차단 없이 최대 2개의 항목을 보낼 수 있습니다. 버퍼 용량에 도달하면 소비자가 최소한 하나의 메시지를 처리할 때까지 생산자는 차단됩니다.

초기 문제로 돌아가서 우리는 동시에 파일을 처리하는 고루틴의 양을 제한하고 싶습니다. 이를 위해 버퍼링된 채널을 활용할 수 있습니다.

ch := make(chan int)

이 예에서는 용량이 5인 버퍼 채널을 추가하여 5개의 파일을 동시에 처리하고 시스템의 부담을 제한할 수 있습니다.

하지만 모든 파일이 동일하지 않다면 어떻게 될까요? 파일 유형이나 파일 크기에 따라 처리하는 데 더 많은 리소스가 필요하다는 것을 확실하게 예측할 수 있습니다. 이 경우 가중치가 부여된 세마포어를 활용할 수 있습니다.

가중 세마포어

간단히 가중치가 부여된 세마포어를 사용하면 단일 작업에 더 많은 리소스를 할당할 수 있습니다. Go는 이미 확장 동기화 패키지 내에서 가중치가 부여된 세마포어에 대한 구현을 제공합니다.

ch := make(chan int, 2)

이 버전에서는 5개 슬롯이 있는 가중치 세마포를 만들었습니다. 예를 들어 이미지만 업로드되는 경우 프로세스는 5개의 이미지를 동시에 처리하지만 PDF를 업로드하는 경우 2개의 슬롯을 획득하므로 처리할 수 있는 파일의 양이 줄어듭니다. 동시에.

결론

동시 작업 수를 제어하기 위해 sync.WaitGroup 및 세마포어를 활용하여 Go에서 몇 가지 동시성 패턴을 탐색했습니다. 그러나 더 많은 도구를 사용할 수 있으므로 채널을 활용하여 작업자 풀을 생성하거나 시간 제한을 추가하거나 팬 인/아웃 패턴을 사용할 수 있습니다.
또한 오류 처리는 단순성을 위해 대부분 생략된 중요한 측면입니다.
오류를 처리하는 한 가지 방법은 채널을 활용하여 오류를 집계하고 모든 고루틴이 완료된 후 오류를 처리하는 것입니다.

Go는 sync.WaitGroups와 관련된 errgroup.Group도 제공하지만 오류를 반환하는 작업 처리를 추가합니다.
패키지는 확장 동기화 패키지에서 찾을 수 있습니다.

위 내용은 고루틴과 채널: Go의 동시성 패턴의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!