Как в Go выполнять HTTP-запросы асинхронно?

Как в Go выполнять HTTP-запросы асинхронно?

• тема: конкурентность, net/http, goroutines
• параллельный запуск запросов выполняется через goroutines
• каждый HTTP-запрос помещается в отдельную goroutine (go func())
• для ожидания завершения и синхронизации применяют sync.WaitGroup или каналы
• ошибки контролируют через каналы либо структуры результатов
• клиент net/http потокобезопасен, поэтому допустимо использовать один общий client
• такой подход подходит для быстрых и масштабируемых обращений к API и сервисам

Подробный ответ для подготовки:

В Go асинхронные HTTP-запросы выполняются с помощью лёгковесных потоков — goroutines. Чтобы отправить несколько запросов одновременно, вызов http.Get или client.Do помещают в отдельную goroutine. После запуска всех операций необходимо дождаться их завершения. Для этого обычно используют sync.WaitGroup: перед созданием каждой goroutine вызывают wg.Add(1), при завершении работы — wg.Done(), а основной поток блокируется на wg.Wait().

Для передачи результатов и ошибок также подходят каналы. Клиент Net/http безопасен при работе из нескольких горутин, поэтому один экземпляр client можно разделять между параллельными запросами.

Такой механизм позволяет масштабировать сетевые операции, запускать множество запросов без блокировки основного потока и рационально расходовать ресурсы.

Пример кода:

var wg sync.WaitGroup
client := &http.Client{}

urls := []string{"http://example.com/a", "http://example.com/b"}

for _, url := range urls {
wg.Add(1)
go func(u string) {
defer wg.Done()
resp, err := client.Get(u)
if err != nil {
log.Println("Error:", err)
return
}
defer resp.Body.Close()
// обработка ответа
}(url)
}

wg.Wait()

Такой ответ показывает понимание конкурентности в Go, потокобезопасности http.Client, способов синхронизации и практического применения goroutines, что обычно хорошо воспринимается на собеседовании.

Подробный ответ

Основной ответ

В Go асинхронный запуск HTTP-запросов обычно строят на горутинах — лёгковесных потоках, которыми управляет рантайм Go. Если поместить каждый запрос в отдельную горутину, множество операций сможет выполняться параллельно, не блокируя основной поток. Для ожидания завершения используют sync.WaitGroup или каналы. Это стандартный и производительный способ организовать асинхронность в Go без callback- и promise-механизмов.

Ключевые моменты

• Горутины запускаются ключевым словом go. Например, используется конструкция go doRequest().
• Когда требуется дождаться нескольких запросов, применяют sync.WaitGroup: он позволяет основному потоку продолжить работу после завершения всех горутин.
• HTTP-клиент Go (net/http) выполняет запросы синхронно, поэтому вызов http.Client.Do(req) помещают в горутину, чтобы отправлять запросы параллельно.
• Для возврата и накопления ответов удобно передавать результаты через каналы в основной поток.
• Важно заранее ограничивать число одновременно выполняемых запросов — например, использовать семафор или буферизированные каналы. Это помогает не перегружать собственную систему и внешние серверы.

Практический контекст

В микросервисах и парсерах нередко требуется выполнять сотни параллельных запросов с небольшой задержкой. Начиная с Go 1.18+ для отмены длительных операций можно применять контекст (context.Context), а для повышения стабильности и производительности — настраивать http.Client, включая таймауты и количество соединений. Распространённый паттерн заключается в запуске множества горутин, передаче результатов через каналы и отдельной обработке ошибок каждого запроса.

Пример простейшего асинхронного запуска HTTP-запросов:

var wg sync.WaitGroup
urls := []string{"http://example.com", "http://golang.org"}

for _, url := range urls {
wg.Add(1)
go func(u string) {
defer wg.Done()
resp, err := http.Get(u)
if err != nil {
log.Println("Error:", err)
return
}
defer resp.Body.Close()
// обработка resp
}(url)
}
wg.Wait()