Category: Go

Легковесная, потребляет мало памяти, имеет низкую задержку — знакомимся с горутиной.

Язык Go, имеющий встроенную поддержку параллельного программирования, представляет вашему вниманию легковесные потоки, выполняющиеся в фоновом режиме. В отличие от потоков, существующих в большинстве других языков — они дешевле с точки зрения занимаемой памяти, межпотокового взаимодействия, имеют низкую задержку и быстрое время запуска. Хотите детальное описание этой сущности — читайте статью!

Определение потока в программировании

Любое работающее приложение, с технической точки зрения — это процесс или, скорее, последовательное выполнение набора инструкций. Эти инструкции исполняются по порядку: сначала первая, потом вторая, затем следующая и так далее. Этот процесс имеет начало и конец.

Отдельный поток подобен процессу и также имеет начало, определенную последовательность действий и конец. Но, в отличие от процесса, поток не является программой и не может работать сам по себе. Вместо этого, он выбирает часть из этой последовательности действий программы и выполняют ее как отдельное приложение. Реальное преимущество этой концепции заключается в том, что потоков может быть несколько, и каждый может одновременно с другими выполнять свою задачу в одной программе.

Простым примером многопоточности является веб-браузер. Ведь в нем можно одновременно загружать файлы, прокручивать страницы вниз, что-то печатать и слушать музыку. Технически, поток можно назвать облегченным процессом, ведь он требует меньше памяти, чем процесс в многопроцессорной среде. Linux обычно обобщает их, называя задачами (они могут быть как процессами, так и потоками).

Однако, между ними все же есть различие.

Что такое Горутины?

Горутины — это дальнейшее усовершенствование концепции потока, а если сказать проще, то это функции, способные работать параллельно с другими такими же функциями в одном адресном пространстве. Причем их настолько хорошо усовершенствовали, что они стали отдельной сущностью. В многопроцессорной среде создание и обслуживание процесса сильно зависят от базовой операционной системы. Процессы потребляют ресурсы операционки и не делят их между узлами. Потоки, хотя и легче, чем процессы, из-за совместного использования ресурсов (между одноранговыми потоками), требуют большого размера стека — почти 1 МБ. Причем стек нужно умножать на количество потоков.

Кроме того, их переключение требует восстановления регистров, таких как программные счетчики, указатели стека, регистры с плавающей запятой и т. д. Из-за этого стоимость обслуживания процесса или потока довольно высока. Кроме того, в случаях, когда данные совместно используются одноранговыми узлами, возникают дополнительные затраты на синхронизацию данных. Хотя накладные расходы на переключение между задачами максимально оптимизированы, постановка новых задач по-прежнему требует больше ресурсов. Иногда это сильно снижает производительность приложения, даже если потоки обозначены как легковесные.

Преимущество горутин в том, что они не зависят от базовой операционной системы, а скорее, существуют в виртуальном пространстве среды выполнения Go. В результате любая оптимизация горутины меньше зависит от платформы, на которой она работает. Они начинают работать с начальной емкости стека размером всего 2-4 КБ и наряду с каналами поддерживают модели параллелизма взаимодействующих последовательных процессов (CSP), где значения передаются между независимыми действиями. Эти действия, как вы уже догадались, называются горутинами.

Как создать горутину в Go

Разработчики должны понимать, что горутины превосходят потоки только количественно. Качественно они одинаковы. При запуске программы в Golang первая горутина вызывает основную функцию и из-за этого ее часто называют основной горутиной. Если же мы захотим создать другие, новые горутины, мы должны использовать оператор go. Например, чтобы вызвать функцию в Golang мы пишем так:

        myfunc()
    

Здесь, после того как ее вызвали, мы опять вернемся к точке вызова. А теперь мы напишем:

        go myfunc()
    

Префикс go вызывает функцию в новой горутине и она (функция) будет выполняться асинхронно с вызвавшим ее участком кода. И если примерно брать в среднем на одну горутину по 4 Кб емкости стека, то имея оперативную память 4Gb, мы сможем создать их около 800 000.

Однако злоупотреблять с ними не стоит, ведь полезны они будут только в следующих случаях:

1. Когда нам необходима асинхронность. Например, при работе с сетью, дисками, базами данных и т. д.
2. При большом времени выполнения функции, когда мы можем что-то выиграть, нагрузив другие ядра.

Среда выполнения Go, работающая в фоновом режиме, начинает запуск набора горутин, с помощью планировщика, распределяющего их по машинам. Затем он создает поток, обрабатывающий все горутины, а максимум определяется переменной GOMAXPROCS.

Давайте рассмотрим простой пример для лучшего понимания работы горутин:

        func main() {
	i:= 10
	go fmt.Printf("1. Значение переменной i равно %d\n", i)
	i++
	go fmt.Printf("2. Значение переменной i равно %d\n", i)
	go func() {
	i++
	go fmt.Printf("3. Значение переменной i равно %d\n", i)
	}()
	i++
	go fmt.Printf("4. Значение переменной i равно %d\n", i)
	time.Sleep(1000000)
}
    

Запуск приведенного выше кода в вашем редакторе приведет к следующему результату:

        4. Значение переменной i равно 12
3. Значение переменной i равно 13
1. Значение переменной i равно 10
2. Значение переменной i равно 11

    

Ниже приведен тот же код, только без использования горутин:

        func main() {
	i:= 10
	fmt.Printf("1. Значение переменной i равно %d\n", i)
	i++
	fmt.Printf("2. Значение переменной i равно %d\n", i)
	func() {
	i++
	fmt.Printf("3. Значение переменной i равно %d\n", i)
	}()
	i++
	fmt.Printf("4. Значение переменной i равно %d\n", i)
	time.Sleep(1000000)
}
    

Здесь ожидаемый результат будет следующим:

        1. Значение переменной i равно 10
2. Значение переменной i равно 11
3. Значение переменной i равно 12
4. Значение переменной i равно 13

    

Когда мы ставим перед любой функцией ключевое слово go, оно создает новую горутину и планирует ее выполнение. Идея и поведение такой сущности полностью идентичны потокам: она имеет полный доступ к аргументам, глобальным переменным и остальным доступным элементам кода. Кроме того, мы можем писать горутины с анонимными функциями. Если вы удалите вызов sleep() в первом примере, вывод не будет показан. Следовательно, вызов функции в конце main приведет к тому, что основная горутина остановится и выйдет до того, как порожденная ею горутина получит какой-либо шанс произвести вывод.

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

Если подытожить, то можно сказать, что горутины — это эффективное ресурсосберегающее средство достижения многозадачности в языке программирования Go. Более подробную информацию по их грамотному использованию можно получить на официальном сайте языка.

Материалы по теме

• 🏎 К чему приводит обилие конкурентности в кодовой базе Go?
• 🏃 Пишем мессенджер на Go за час: 7 простых шагов от эхо-сервера к асинхронному обмену сообщениями
• 🏃 Самоучитель для начинающих: как освоить Go с нуля за 30 минут?

В статье поговорим о том, какие проблемы возникают при конкурентном обращении нескольких потоков к одним и тем же данным.

Проблемы многопоточной разработки

В наше время существуют десятки крупных компаний, одновременно обслуживающих миллионы клиентов по всему миру и оказывающих им различные услуги. При этом, многие из них используют Go в качестве основного языка программирования для разработки своих микросервисов, архитектура которых порой работает на нескольких миллионах процессорных ядер. К примеру, монорепозиторий известного перевозчика Uber содержит около 46 миллионов строк кода и около 2100 уникальных сервисов. Использование языка Go для этих целей обусловлено рядом весомых преимуществ: грамотно настроенный параллелизм, простая настройка сборки мусора, минималистичный подход к синтаксису, отличные инструменты для дальнейшей обработки и обслуживания кода, поддержка библиотек, а также растущее с каждым днем, сообщество разработчиков.

В своей работе, Go-разработчики для передачи и обмена информацией используют легковесные потоки – горутины. Так вот, при параллельном обращении нескольких горутин к одним и тем же данным и начинают возникать большие проблемы, называемые в Go – состоянием гонки (Race conditions). А учитывая обилие кодовой базы и количество обрабатываемых одновременно процессов – проблема принимает глобальный масштаб. В статье попробуем разобраться, что это за напасть такая и как от нее избавиться.

Параллелизм и конкурентность

Прежде чем поговорить о гонках данных (data races), необходимо упомянуть о концепциях параллелизма и конкурентности, с которыми обязательно нужно разобраться, перед тем как заниматься многопоточной разработкой. Эти понятия схожи, но имеют существенные различия – «Concurrency is not Parallelism!». Суть этого расхожего выражения в том, что конкурентность – это методика проектирования вашей программы, параллелизм – это один из способов ее выполнения.

Говорить о конкурентности можно, когда работа приложения предполагается с несколькими одновременно запущенными задачами при создании процессов, выполняющихся независимо друг от друга. При этом, для достижения необходимого поведения, процессов в приложении может быть большое количество.

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

При этом говорить о параллелизме мы не можем, ведь задачи не могут выполняться вместе просто потому, что система у нас – одноядерная.

Проще говоря, когда мы имеем несколько одновременно выполняющихся потоков инструкций – надо делать так, чтобы код выполнялся параллельно, а этот процесс требует конкурентности. Ведь при отсутствии конкурентного дизайна распараллелить нашу программу не выйдет. А вот сама по себе концепция конкурентности не обязательно нуждается в параллелизме, ведь если программа способна работать на нескольких ядрах, она спокойно может функционировать и на одном.

Состояния гонки в Go

Проблемы, относящиеся к категории состояние гонки, довольно трудно обнаружить и поэтому они относятся к группе самых непредсказуемых ошибок программирования. Довольно часто при запуске кода они вызывают загадочные сбои, понять природу которых не может и матерый разработчик. При этом, даже упрощающий написание чистого кода механизм конкурентности, не сможет предотвратить Race conditions. В таких случаях, от программиста требуется осторожность, больше усердия и грамотное тестирование.

Гонка происходит, когда две или более горутины обращаются к одним и тем же данным. Сбои, вызванные гонками данных в программах Go, повторяются и зачастую снижают эффективность и производительность наиболее важных функций, что будет доставлять неудобства вашим клиентам и повлияет на их доход. Порой разработчикам довольно трудно отлаживать data races и иногда некоторые из них исправляют такие ошибки с помощью консервативных методов. Одним из которых является отключение параллелизма в подозрительных областях кода.

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

Детектор гонки

Впервые этот набор инструментов, определяющих состояния гонки в Go-коде, появился в версии 1.1 и по сей день, успешно работает на операционках Linux, OS X и Windows с 64-разрядными процессорами x86.

В основе детектора лежит библиотека времени выполнения (runtime library) C/C++ – ThreadSanitizer, используемая для обнаружения ошибок в кодовой экосистеме Google и Chromium. Внедрили эту технологию в Go в сентябре 2012, и после этого она стала частью непрерывного процесса сборки по отслеживанию условий гонки при их возникновении.

Race detector встроен в цепочку инструментов Go и работает следующим образом:

• В необходимых нам подозрительных местах мы устанавливаем флаг командной строки -race, показывающий компилятору полный список обращений к памяти с помощью кода, описывающего основные параметры осуществления доступ к памяти.
• А тем временем, ThreadSanitizer ищет в коде несинхронизированные обращения к общим переменным и, обнаружив такое «грубое» поведение, выдает предупреждение.

Детектор сконструирован таким образом, что он в состоянии обнаружить Race conditions только при фактическом запуске кода. Поэтому важно осуществлять запуск двоичных файлов приложения при реалистичных рабочих нагрузках.

Но двоичный файл с детектором гонки может сильно влияет на производительность процессора и памяти, вызывая перегрузку системы – поэтому не стоит держать детектор гонки включенным постоянно. Хорошей практикой является запуск его, вместе с нагрузочными и интеграционными тестами, ведь они, в большинстве своем, используют конкурентные части кода.

Как использовать детектор гонки

Как мы уже упоминали ранее, для того, чтобы подключить к необходимому участку кода включенный детектор гонки, к нему нужно добавить флаг -race, например:

        $ go test -race pack // тестируем пакет
$ go run -race src.go // компилируем и запускаем программу
$ go build -race cmd // сборка команды
$ go install -race pack // устанавливаем пакет
    

Рассмотрим пример упрощенной версии фактической ошибки, которую обнаружил детектор гонки. Здесь он с помощью таймера выводит сообщения с произвольным интервалом от 0 до 1 секунды. Все это действие повторяется пять секунд.

Он использует time.AfterFunc для создания Timer для первого сообщения, а затем использует метод Reset для планирования следующего сообщения, каждый раз повторно используя Timer.

        func main() {
start := time.Now()
var t *time.Timer
 t = time.AfterFunc(randomDuration(), func() {
 fmt.Println(time.Now().Sub(start))
 t.Reset(randomDuration())
 })
time.Sleep(5 * time.Second)
}
func randomDuration() time.Duration {
   return time.Duration(rand.Int63n(1e9))
}

    

Race detector – мощнейший инструмент, проверяющий корректность всех параллельных программ, к предупреждениям которого нужно отнестись со всей серьезностью, ведь ложных срабатываний он не выдает. Обратите внимание, что детектор находит лишь те гонки, которые могут появиться в процессе выполнения приложения, поэтому он не может найти их на участках кода, которые не выполняются.

Материалы по теме

• 👨‍🎓️ ТОП-11 бесплатных учебных курсов по Go
• 🏃 Пишем мессенджер на Go за час: 7 простых шагов от эхо-сервера к асинхронному обмену сообщениями
• 🏃 43 ресурса для изучения Go в 2021 году: сайты, блоги, сообщества, курсы, каналы и книги

Авторы большинства статей по сокетным соединениям в примерах ограничиваются реализацией эхо-сервера. Давайте разовьем эту тему и за 7 простых шагов сделаем вместе консольный мессенджер сообщений.

Шаг 1. Ищем код эхо-сервера

Если скомпилировать исходники и запустить в отдельных консолях клиент и сервер, то можно обмениваться сообщениями. У этого сервера есть один значительный недостаток: он работает только с одним клиентом. Попробуем запустить в еще одной консоли новый клиент и увидим, как она зависнет. То же самое будет и с четвертым, и с пятым клиентом.

Шаг 2. Реализуем прием нескольких соединений

Чтобы принять несколько одновременных соединений, необходимо:

• функцию приема соединения conn.Accept() заключить еще в один цикл for.
• весь код, который был в цикле, вынести в отдельную функцию process().
• запустить функцию process() как отдельную горутину в цикле for сразу после приема соединения conn.Accept()

В результате небольших изменений наш код примет следующий вид:

           // функция process запускается как горутина
    func process(conn net.Conn){
      // определим, что перед выходом из функции, мы закроем соединение
      defer conn.Close
      for {
         // Будем прослушивать все сообщения разделенные \n
         message, _ := bufio.NewReader(conn).ReadString('\n')
         // Распечатываем полученое сообщение
         fmt.Print("Message Received:", string(message))
         // Отправить новую строку обратно клиенту
         conn.Write([]byte(message + "\n")){
        }
    } 
    

Код в main:

             // Устанавливаем прослушивание порта
    ln, _ := net.Listen("tcp", ":8081")
    // выполнение цикла обработки соединений
    for {    
      // Принимаем входящее соединение
      conn, _ := ln.Accept()
      // запускаем функцию process(conn)   как горутину
      go process(conn)
    }
    

Если мы запустим в одной консоли сервер, а в нескольких других консолях программу клиента, то можно видеть, что сервер может обрабатывать уже несколько соединений с клиентами параллельно. На самом деле он их обрабатывает асинхронно: сперва один запрос, потом другой, осуществляя переключения между горутинами.

Шаг 3. Обрабатываем ошибки соединений

Давайте попробуем отсоединить один из клиентов, убив его процесс: наш сервер зациклится. Если что-нибудь набрать в клиенте, то данные куда-то уходят, и клиент ни о чём не подозревает.

Мы забыли обработать ошибки ввода-вывода. Функция вывода в сокет Write имеет два выходных параметра: кол-во считанных байт и ошибку:

        data_len, err := conn.Write(b []byte)
    

Если ошибка не пустая (т.е. не равна nil ), значит мы не смогли принять данные. Какая ошибка произошла, можно узнать с помощью функции err.Error()

Заменим conn.Write(b []byte) на следующий код:

        _ , err := conn.Write(b []byte)
if err != nil {
          fmt.Println(err.Error)
          break  // выходим из цикла и функции
} 
    

Аналогичный код пропишем в клиенте. Еще в клиенте отсутствует отложенное закрытие соединения, которое срабатывает при выходе из функции defer conn.Close().

Теперь при закрытие клиента или сервера, у нас будет выдаваться сообщение:

        write tcp 127.0.0.1:8081->127.0.0.1:40296: write: broken pipe
    

Шаг 4. Простой прототип мессенджера

К этому моменту мы допилили эхо-сервер, а теперь осталось сделать простой из него мессенджер. Пусть логика мессенджера будет следующей:

• Клиент коннектится к серверу и получает номер сообщения. Каждай клиент имеет свой уникальный номер.
• Клиент отправляет сообщение серверу с указанием номера клиента, кому адресовано это сообщение.
• Сервер принимает сообщение от клиента, декодирует его и отправляет тому клиенту, которому адресовано это сообщение.

Введем счетчик входящих соединений, а каждое новое соединение сохраним в xeштаблице, организовав таким образом пул:

        conns := make( map[int] net.Conn, 1024)
    

Каждое соединение после conn.Accept() мы сохраним в conns, а в функцию process() будем передавать весь пул (хештаблицу) и номер текущего соединения. В функции обработки соединения process() мы можем иметь доступ ко всем активным соединениям. Не забываем увеличивать на единицу счетчик текущих соединений.

В функции process() мы принимаем не текущее соединение, а пул и номер текущего соединения. Следовательно, чтоб получить доступ к текущему соединению, мы можем его взять из пула:

        conn := conn[n]
    

Новый код сервера:

        func process(conns map[int]net.Conn, n int) {
  // получаем доступ к текущему соединению
  conn := conns[n]
  // определим, что перед выходом из функции, мы закроем соединение
  defer conn.Close()
  for {
    // Будем прослушивать все сообщения разделенные \n
    message, _ := bufio.NewReader(conn).ReadString('\n')
    // Распечатываем полученое сообщение
    fmt.Print("Message Received:", string(message))
    // Отправить новую строку обратно клиенту
    _, err := conn.Write([]byte(strconv.Itoa(n) + "->> " + message + "\n"))
    // анализируем на ошибку
    if err != nil {
      fmt.Print(err.Error())
      break // выходим из цикла
    }
  }
}
func main() {
  fmt.Println("Start server...")
  // создаем пул соединений
  conns := make(map[int]net.Conn, 1024)
  i := 0
  // Устанавливаем прослушивание порта
  ln, _ := net.Listen("tcp", ":8081")
  // объвляем пул соединений на 1024 соединения
  conns := make(map[int]net.Conn, 1024)
  // Запускаем цикл обработки соединений
  for {
    // Принимаем входящее соединение
    conn, _ := ln.Accept()
    // сохраняем соединение в пул
    conns[i] = conn
    // запускаем функцию process(conn)   как горутину
    go process(conns, i)
    i++
  }
}
    

При тестировании мы видим, что в каждом ответном сообщении сервер возвращает клиенту номер текущего соединения:

        ./client
Text to send: msg from 1
Message from server: 1->> msg from 1
    

Шаг 5. Реализация протокола обмена

Пример:

        2 Оправляем сообщение второму клиенту
    

Для реализации этого протокола, необходимо сделать парсинг сообщения. Номер клиента, мы вытащим, используя fmt.Scanf(), а само сообщение с использованием слайса:

        // парсинг полученного сообщения
fmt.Sscanf(message, "%d", &clientNo) // определи номер клиента
pos := strings.Index(message, " ") // нашли позицию разделителя
out_message := message[pos:] // взяли хвост сообщение после пробела

    

Дальше все очень просто: зная номер соединения (clientNo) клиента, мы будем отправлять ответ в нужное соединение. Сообщение было немного изменено, и теперь мы выводим, от какого клиента оно исходит:

        conns[clientNo].Write([]byte(strconv.Itoa(clientNo) + "->> " + out_message + "\n"))
    

Шаг 6. Распараллеливание кода

Выход довольно простой: нужно чтение из сокета и чтение с консоли сделать асинхронными, т.е. сделать так, чтобы ввод из сокета и ввод из консоли не блокировали друг друга. Как говорилось выше, горутины позволяют коду выполняться асинхронно. Следовательно, должны быть запущены две разные горутины: одна должна осуществлять чтение с консоли, а вторая – чтение из сокета.

Первая горутина читает данные из сокета, и если в сокете есть данные, выводит их на печать. Чтение и вывод должны быть заключены в цикл:

        // прием данных из сокета и вывод на печать
func readSock(conn net.Conn ) {
    buf := make([]byte,256)
    for {
        readed_len, _ := conn.Read(buf)
        if readed_len > 0 {            
            fmt.Print(string(buf))
        }
    }
}

    

Со второй горутиной все немного сложнее, поскольку она должна передать данные в основную программу. Почему нельзя сразу писать их в сокет, как это делает первая горутина? Увы, операция conn.Write() – блокирующая, и если мы так сделаем, то можем заблокировать другие операции ввода-вывода. Все блокирующие операции нужно разнести по разным асинхронным частям программы.

        // ввод данных с консоли и вывод их в канал
func readConsole(ch chan string) {
    for {
        fmt.Print(">")
        line, _ := bufio.NewReader(os.Stdin).ReadString('\n')
        out :=line[:len(line)-1] // убираем символ возврата каретки
        ch <- out // отправляем данные в канал
    }
}

    

Основная программа должна запустить две асинхронных горутины: чтение с консоли и из сокета (в цикле читать канал и если в нем есть данные, то записать их в сокет). Чтобы наше консольное приложение не «съело» все ресурсы CPU, необходимо ввести некоторую задержку: time.Sleep(time.Seconds * 2)

Должно получиться примерно следующее:

        func main(){
    ch := make(chan string)

    defer close(ch) // закрываем канал при выходе из программы

    conn, _ := net.Dial("tcp", "127.0.0.1:8080")

    go readConsole(ch)
    go readSock(conn)

    for {
        val, ok := <- ch
        if ok { // если есть данные, то их пишем в сокет

            _, err := conn .Write([]bytes(val))
            if err != nil {
                fmt.Println("Write:", err.Error())
                break
            }
        } else {
            // данных в канале нет, задержка на 2 секунды
            time.Sleep(time.Second * 2)
        }

    }
    fmt.Println("Finished...")
    conn.Close()
}

    

Шаг 7. Повышаем надежность выполнения кода

Наше приложение должно работать при любых входных данных, даже если они некорректные. Есть несколько простых правил, которые придется соблюдать при построении любых приложений:

• необходимо проверять все входящие данные и если их длинна больше принимающего буфера, то либо обрезать их, либо генерировать ошибку;
• необходимо обрабатывать все функции ввода-вывода на возможность возникновения ошибки.

Например, в коде было много сокращений и специально была опущена обработка функций conn.Accept() и net.Dial():

            ls,err := conn.Accept()
    if err != nil {
        fmt.Println(err)
        panic("accept")
    }

    

Также был опущен код обработки объема данных с консоли:

            // ввод данных с консоли
    for {
        fmt.Print(">")
        line, _ := bufio.NewReader(os.Stdin).ReadString('\n')
        if len(line) > 250 {
            fmt.Println("Error: message is very lagre")
            continue
        }
        ch <- b
    }    
    

Почти готовое и работоспособное решение можно найти в репозитории: вам остается самостоятельно дописать обработку всех ошибок ввода-вывода. Если возникнет желание сделать pull request в репозиторий, то я смогу указать в комментариях на ошибки или просто похвалить. Сделайте свой код достоянием общественности. Удачи!

Большинство статей про использование MySQL в Golang повторяет примеры из официального руководства. Реальная разработка далека от простых примеров: из-за строгой типизации часто возникают проблемы. Разбираемся с их решением, если вам необход…

Большинство статей про использование MySQL в Golang повторяет примеры из официального руководства. Реальная разработка далека от простых примеров: из-за строгой типизации часто возникают проблемы. Разбираемся с их решением, если вам необход…

В Go (Golang) нет специального механизма обработки исключений, и создатели языка не собираются его добавлять. Попробуем разобраться, хорошо это или плохо и как лучше разрешать проблемные ситуации в приложениях.

…

Изучаем основы параллельного программирования в Go, а также пытаемся разобраться на примерах, почему конкурентность в Go – это не совсем параллелизм.

Перевод публикуется с сокращен…

В первой статье мы строили Worker Pool для оптимизации производительности. Во второй части мы создадим надежное решение для работы со структурами конкурентности.

Перевод публикуетс…

В первой статье мы строили Worker Pool для оптимизации производительности. Во второй части мы создадим надежное решение для работы со структурами параллелизма.

Перевод публикуется …

В современных языках программирования параллелизм стал безусловной потребностью. В этой статье речь пойдет об устройстве и использовании concurrency в Go.

Перевод публикуется с сок…

Cортировки и битовые маски, обработка ошибок и создание изображений, генерация перестановок и работа с хэш-суммами, запуск HTTP-сервера, юнит-тесты и другие распространенные задачи, решаемые с помощью Go.

…