Введение в параллелизм в Go

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

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

Параллелизм в Go

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

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

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

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

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

Среда выполнения Go управляет горутинами. Горутины имеют свой стек, что позволяет им занимать мало места с начальным размером стека в несколько килобайт.

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

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

функцияосновной() {
идти функция1() // Создаем и выполняем горутину для function1
идти функция2() // Создаем и выполняем горутину для function2
// ...
}
функцияфункция1() {
// Код функции1
}
функцияфункция2() {
// Код функции2
}

Когда программа вызывает функция1() и функция2() с идти ключевое слово, среда выполнения Go выполняет функции одновременно как горутины.

Вот пример использования горутины, выводящей текст на консоль:

упаковка основной
Импортировать (
"ФМТ"
"время"
)
функцияпечатьТекст() {
для я := 1; я <= 5; я++ {
 ФМТ. Распечатать("Печать текста", я)
 время. Спать(1 * время. Второй)
 }
}
функцияосновной() {
идти печататьтекст() // Запускаем горутину для одновременного выполнения функции printText
// Выполнение других задач в основной горутине
для я := 1; я <= 5; я++ {
 ФМТ. Распечатать(«Выполнение других задач», я)
 время. Спать(500 * время. Миллисекунда)
 }
// Ждем завершения горутины
 время. Спать(6 * время. Второй)
}

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

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

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

Использование каналов для связи и синхронизации

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

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

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

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

функцияосновной() {
// Создаем небуферизованный канал типа string
 ч := делать(Чаннить)
// Горутина 1: отправляет сообщение в канал
идтифункция() {
 ч "Здравствуй, Канал!"
 }()
// Горутина 2: получает сообщение из канала
 сообщение :=  ФМТ. Распечатать (сообщение) // Вывод: Привет, канал!
}

Канал в г. основной функция представляет собой небуферизованный канал с именем ч созданный с помощью делать() функция. Первая горутина отправляет сообщение «Привет, канал!» в канал с помощью оператора, а вторая горутина получает сообщение из канала с помощью того же оператора. Наконец, основной функция выводит полученное сообщение на консоль.

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

функцияосновной() {
// Небуферизованный канал
 ч1 := делать(Чанинт)
// Буферизованный канал емкостью 3
 ч2 := делать(Чаннить, 3)
// Отправка и получение значений из каналов
 ч1 42// Отправляем значение в ch1
 значение1 := // Получаем значение из ch1
 ч2 "Привет"// Отправляем значение в ch2
 значение2 := // Получаем значение из ch2
}

основной функция создает два канала: ч1 является небуферизованным целочисленным каналом, а ч2 представляет собой буферизованный строковый канал емкостью 3. Вы можете отправлять и получать значения в эти каналы и из них, используя оператор (значения должны быть указанного типа).

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

функцияосновной() {
 ч := делать(Чанлогический)
идтифункция() {
 ФМТ. Распечатать("Горутина 1")
 ч истинный// завершение сигнала
 }()
идтифункция() {
 // Ждем сигнала завершения от Goroutine 1
 ФМТ. Распечатать("Горутина 2")
 }()
 // Ждем сигнала завершения от Goroutine 2
 ФМТ. Распечатать(«Главная горутина»)
}

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

Вы можете создавать веб-приложения в Go With Gin

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

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