На данный момент я нахожусь в активном поиске нового проекта, поэтому активно хожу на собеседования.
Решил поделиться своими мыслями о решении задачи, которую (как мне кажется) часто дают на собеседованиях.
Задача
Написать функцию, которая принимает несколько url адресов, а отдает сумму байт body ответов списка адресов и ошибку, если что-то пошло не так (если произошла ошибка, нужно вернуть ошибку как можно скорее, значение - не важно).
Интересно обсудить варианты решения?
Итак, у нас отдельная программа. Есть 2 набора данных - с успешным и не успешным кейсом. Причем в наборах данных неуспешного кейса специально включены разные зоны. Набор данных придумывал я сам, поэтому если считаете, что их охват не полный, напишите в комментариях.
Банальный вариант
В банальном варианте (чтобы работало) мы берем и просто обходим весь набор данных. Зато вариант - рабочий!
// Банальный синхронный вариант
package main
import (
"fmt"
"io"
"net/http"
"time"
)
const byteInMegabyte = 1024 * 1024
func main() {
urlsList1 := []string{
"https://youtube.com",
"https://ya.ru",
"https://reddit.com",
"https://google.com",
"https://mail.ru",
"https://amazon.com",
"https://instagram.com",
"https://wikipedia.org",
"https://linkedin.com",
"https://netflix.com",
}
urlsList2 := append(urlsList1, "https://111.321", "https://999.000")
{
t1 := time.Now()
byteSum, err := requesSumm(urlsList1)
fmt.Printf("Сумма страниц в Мб=%.2f, ошибка - %v \n", (float64(byteSum) / byteInMegabyte), err)
fmt.Printf("Время выполнение запросов %.2f сек. \n", time.Now().Sub(t1).Seconds())
}
fmt.Println("++++++++")
{
t1 := time.Now()
byteSum, err := requesSumm(urlsList2)
fmt.Printf("Сумма страниц в Мб=%.2f, ошибка - %v \n", (float64(byteSum) / byteInMegabyte), err)
fmt.Printf("Время выполнение запросов %.2f сек. \n", time.Now().Sub(t1).Seconds())
}
}
func requesSumm(urlsSlv []string) (int64, error) {
var sum int64
client := &http.Client{
Timeout: 10 * time.Second,
}
for _, v := range urlsSlv {
resp, err := client.Get(v)
if err != nil {
return 0, err
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return 0, err
}
sum += int64(len(body))
}
return sum, nil
}
Время выполнение, как думаю понятно из определения, равно сумме всех запросов.
ilia@goDevLaptop sobesi % go run httpget/v1.go
Сумма страниц в Мб=2.12, ошибка - <nil>
Время выполнение запросов 16.01 сек.
++++++++
Сумма страниц в Мб=0.00, ошибка - Get "https://111.321": context deadline exceeded (Client.Timeout exceeded while awaiting headers)
Время выполнение запросов 18.88 сек.
ilia@goDevLaptop sobesi %Затем очевидный вариант для языка Golang - это подключение асинхронного вызова, основанного на отдельных горутинах. Давайте посмотрим, как изменится время выполнения?
// Банальный ассинхронный вариант
package main
import (
"fmt"
"io"
"net/http"
"sync"
"time"
)
const byteInMegabytev2 = 1024 * 1024
type respSt struct {
lenBody int64
err error
}
func main() {
urlsList1 := []string{
"https://youtube.com",
"https://ya.ru",
"https://reddit.com",
"https://google.com",
"https://mail.ru",
"https://amazon.com",
"https://instagram.com",
"https://wikipedia.org",
"https://linkedin.com",
"https://netflix.com",
}
urlsList2 := append(urlsList1, "https://111.321", "https://999.000")
{
t1 := time.Now()
byteSum, err := requesSummAsync(urlsList1)
fmt.Printf("Сумма страниц в Мб=%.2f, ошибка - %v \n", (float64(byteSum) / byteInMegabytev2), err)
fmt.Printf("Время выполнение запросов %.2f сек. \n", time.Now().Sub(t1).Seconds())
}
fmt.Println("++++++++")
{
t1 := time.Now()
byteSum, err := requesSummAsync(urlsList2)
fmt.Printf("Сумма страниц в Мб=%.2f, ошибка - %v \n", (float64(byteSum) / byteInMegabytev2), err)
fmt.Printf("Время выполнение запросов %.2f сек. \n", time.Now().Sub(t1).Seconds())
}
}
func requesSummAsync(urls []string) (int64, error) {
var wg sync.WaitGroup
ansCh := make(chan respSt, len(urls))
client := &http.Client{
Timeout: 10 * time.Second,
}
for _, url := range urls {
wg.Add(1)
go func(u string) {
defer wg.Done()
resp, err := client.Get(u)
if err != nil {
ansCh <- respSt{
lenBody: 0,
err: err,
}
return
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
ansCh <- respSt{
lenBody: 0,
err: err,
}
return
}
ansCh <- respSt{
lenBody: int64(len(body)),
err: nil,
}
}(url)
}
go func() {
wg.Wait()
close(ansCh)
}()
var sum int64
var err error
for bodyLen := range ansCh {
sum += bodyLen.lenBody
if bodyLen.err != nil {
if err == nil {
err = fmt.Errorf("Ошибка %v у сайта %v", bodyLen.err)
continue
}
err = fmt.Errorf("Ошибка %v у сайта %v;%v", bodyLen.err, err)
}
}
if err != nil {
return 0, err
}
return sum, err
}
Фактически время выполнение будет равно выполнению самого медленного запроса + время на сложение.
ilia@goDevLaptop sobesi % go run httpget/v2.go
Сумма страниц в Мб=2.50, ошибка - <nil>
Время выполнение запросов 2.81 сек.
++++++++
Сумма страниц в Мб=0.00, ошибка - Ошибка Get "https://111.321": context deadline exceeded (Client.Timeout exceeded while awaiting headers) у сайта Ошибка Get "https://999.000": dial tcp: lookup 999.000: no such host у сайта %!v(MISSING);%!v(MISSING)
Время выполнение запросов 10.00 сек.
ilia@goDevLaptop sobesi %Тайм аут запроса 10 секунд, но можно ли улучшить скорость в нашей задаче?
Давайте дополним реализацию выше еще и общим контекстом, который будет общим для всех созданных горутин.
// Ассинхронный вариант с контекстом
package main
import (
"context"
"errors"
"fmt"
"io"
"net/http"
"sync"
"time"
)
type respStC struct {
lenBody int64
err error
}
const byteInMegabytev3 = 1024 * 1024
func main() {
urlsList1 := []string{
"https://youtube.com",
"https://ya.ru",
"https://reddit.com",
"https://google.com",
"https://mail.ru",
"https://amazon.com",
"https://instagram.com",
"https://wikipedia.org",
"https://linkedin.com",
"https://netflix.com",
}
urlsList2 := append(urlsList1, "https://111.321", "https://999.000")
{
t1 := time.Now()
byteSum, err := requestSumAsyncWithCtx(urlsList1)
fmt.Printf("Сумма страниц в Мб=%.2f, ошибка - %v \n", (float64(byteSum) / byteInMegabytev3), err)
fmt.Printf("Время выполнение запросов %.2f сек. \n", time.Now().Sub(t1).Seconds())
}
fmt.Println("++++++++")
{
t1 := time.Now()
byteSum, err := requestSumAsyncWithCtx(urlsList2)
fmt.Printf("Сумма страниц в Мб=%.2f, ошибка - %v \n", (float64(byteSum) / byteInMegabytev3), err)
fmt.Printf("Время выполнение запросов %.2f сек. \n", time.Now().Sub(t1).Seconds())
}
}
func requestSumAsyncWithCtx(urls []string) (int64, error) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
var wg sync.WaitGroup
ansCh := make(chan respStC, len(urls))
client := &http.Client{
Timeout: 10 * time.Second,
}
for _, url := range urls {
wg.Add(1)
go func(u string) {
defer wg.Done()
req, err := http.NewRequestWithContext(ctx, "GET", u, nil)
if err != nil {
ansCh <- respStC{lenBody: 0, err: err}
return
}
resp, err := client.Do(req)
if err != nil {
ansCh <- respStC{lenBody: 0, err: err}
return
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
ansCh <- respStC{lenBody: 0, err: err}
return
}
ansCh <- respStC{lenBody: int64(len(body)), err: nil}
}(url)
}
go func() {
wg.Wait()
close(ansCh)
}()
var sum int64
var err error
for bodyLen := range ansCh {
sum += bodyLen.lenBody
if bodyLen.err != nil && !errors.Is(bodyLen.err, context.Canceled) {
if err != nil {
err = fmt.Errorf("Ошибка %v у сайта %v;%v", bodyLen.err, bodyLen.lenBody, err)
} else {
err = fmt.Errorf("Ошибка %v у сайта %v", bodyLen.err, bodyLen.lenBody)
}
cancel()
}
}
return sum, err
}
Теперь посмотрим на время исполнения.
ilia@goDevLaptop sobesi % go run httpget/v3.go
Сумма страниц в Мб=2.50, ошибка - <nil>
Время выполнение запросов 2.89 сек.
++++++++
Сумма страниц в Мб=0.00, ошибка - Ошибка Get "https://999.000": dial tcp: lookup 999.000: no such host у сайта 0
Время выполнение запросов 0.00 сек.
ilia@goDevLaptop sobesi %И вот уже получается, что мы можем не ждать каждый запрос, а вернем ошибку сразу.
Но реальная жизнь, это всегда борьба с ограничениями, и, если нам дадут слишком большой список (больше доступных сетевых соединений) в той среде, где выполняется программа, то мы уже получим не определенное поведение как нашей программы, так и среды вокруг. Поэтому мы ограничим возможность программы создавать больше заданного количества сетевых соединений одновременно.
Для этого конечно мы воспользуемся буфферизированным каналом ;-)
// Ассинхронный вариант с контекстом и пулом соединений в poolHTTPReq
package main
import (
"context"
"errors"
"fmt"
"io"
"net/http"
"sync"
"time"
)
type respStCWP struct {
lenBody int64
err error
}
const poolHTTPReq = 2
const byteInMegabytev4 = 1024 * 1024
func main() {
urlsList1 := []string{
"https://youtube.com",
"https://ya.ru",
"https://reddit.com",
"https://google.com",
"https://mail.ru",
"https://amazon.com",
"https://instagram.com",
"https://wikipedia.org",
"https://linkedin.com",
"https://netflix.com",
}
urlsList2 := append(urlsList1, "https://111.321", "https://999.000")
{
t1 := time.Now()
byteSum, err := requestSumAsyncWithCtxAndPool(urlsList1)
fmt.Printf("Сумма страниц в Мб=%.2f, ошибка - %v \n", (float64(byteSum) / byteInMegabytev4), err)
fmt.Printf("Время выполнение запросов %.2f сек. \n", time.Now().Sub(t1).Seconds())
}
fmt.Println("++++++++")
{
t1 := time.Now()
byteSum, err := requestSumAsyncWithCtxAndPool(urlsList2)
fmt.Printf("Сумма страниц в Мб=%.2f, ошибка - %v \n", (float64(byteSum) / byteInMegabytev4), err)
fmt.Printf("Время выполнение запросов %.2f сек. \n", time.Now().Sub(t1).Seconds())
}
}
func requestSumAsyncWithCtxAndPool(urls []string) (int64, error) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
var wg sync.WaitGroup
ansCh := make(chan respStCWP, len(urls))
semaphore := make(chan struct{}, poolHTTPReq)
for _, url := range urls {
semaphore <- struct{}{}
wg.Add(1)
go func(u string) {
defer func() {
<-semaphore
wg.Done()
}()
req, err := http.NewRequestWithContext(ctx, "GET", u, nil)
if err != nil {
ansCh <- respStCWP{lenBody: 0, err: err}
return
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
ansCh <- respStCWP{lenBody: 0, err: err}
return
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
ansCh <- respStCWP{lenBody: 0, err: err}
return
}
ansCh <- respStCWP{lenBody: int64(len(body)), err: nil}
}(url)
}
go func() {
wg.Wait()
close(ansCh)
close(semaphore)
}()
var sum int64
var err error
for bodyLen := range ansCh {
sum += bodyLen.lenBody
if bodyLen.err != nil && !errors.Is(bodyLen.err, context.Canceled) {
if err != nil {
err = fmt.Errorf("Ошибка %v у сайта %v;%v", bodyLen.err, bodyLen.lenBody, err)
} else {
err = fmt.Errorf("Ошибка %v у сайта %v", bodyLen.err, bodyLen.lenBody)
}
cancel()
}
}
return sum, err
}
И получим значения, конечно, хуже предыдущего варианта, но уже более приближенные к жизни.
ilia@goDevLaptop sobesi % go run httpget/v4.go
Сумма страниц в Мб=2.50, ошибка - <nil>
Время выполнение запросов 9.05 сек.
++++++++
Сумма страниц в Мб=2.12, ошибка - Ошибка Get "https://999.000": dial tcp: lookup 999.000: no such host у сайта 0
Время выполнение запросов 4.29 сек.
ilia@goDevLaptop sobesi % Весь код естественно выложен на GitHub
Если вам интересны подобные статьи или у вас есть вопросы, замечания, пожелания - обязательно напишите комментарий.
А так же подписывайтесь на мой телеграмм канал, где я публикую свои мысли на все интересное, что попадает мне на глаза из мира it.
