Одним из самых популярных аспектов языка программирования Go является его первоклассная поддержка способности компьютера выполнять множество задач одновременно. Возможность одновременного выполнения кода становится все более важной в программировании, поскольку компьютеры переходят от быстрого выполнения одного потока кода к одновременному выполнению многих потоков. Чтобы программы выполнялись быстрее, программисты должны проектировать их так, чтобы каждый параллельный элемент системы мог выполняться независимо от других.
Две функциональные возможности Go, Goroutines и каналы, упрощают параллелизм, когда используются вместе. Goroutines предлагает базовый первичный тип для этой возможности. Goroutines менее затратны в отношении пространства памяти, межпоточного взаимодействия и сетевого подключения. Они также имеют лучшее время запуска, чем потоки, которые поддерживаются многими языками программирования. По сути, Go относится к Goroutines как то, что Java и другие языки программирования называют потоками.
Что такое Goroutines?
Горутина - это простой поток реализации в Golang, который выполняется одновременно с остальной частью программы. Goroutines доступны при сходстве со стандартными потоками, поскольку стоимость создания горутины чрезвычайно мала. Поэтому они широко используются в Go для параллельного программирования. Каждая программа состоит как минимум из одной программы, известной как главная программа. Главная горутина управляет всеми другими горутинами; таким образом, если главная горутина завершается, то завершаются и все остальные горутины в сценарии. Goroutine всегда активна в фоновом режиме.
Пример: Вот иллюстрация: вы пишете что-то в своем блокноте и проголодались; вы сделаете перерыв и перекусите. Затем снова начинаете писать. Теперь вы выполняете две роли (пишете и едите) в течение времени, которое считается одновременной занятостью. Следует подчеркнуть, что эти две задачи (писать и есть) все равно должны выполняться одновременно. Когда элементы выполняются одновременно, это называется параллелизмом (представьте, что вы пользуетесь мобильным телефоном, одновременно поедая чипсы). Параллелизм включает в себя взаимодействие со многими вещами одновременно. Параллелизм (одновременное выполнение многих действий) является подклассом этого (не обязательно одновременное выполнение) с некоторым расписанием.
Мы можем добавить горутину, применив ключевое слово go к вызову функции. Как только мы применим ключевое слово go к вызову функции, мы установим параллелизм с производительностью. Но сначала давайте определим эффект от применения ключевого слова go к выполнению. Рассмотрим, что в программе есть две горутины. Текст "package main import" будет входом программы. В Go, пакет main import является декларативным оператором импорта. Главная горутина (first goroutine) подразумевается. Когда мы выполняем go (f), формируется вторая goroutine (0). Обычно при выполнении функции наша программа выполняет каждую команду в основной функции, прежде чем перейти к следующей строке.
С помощью goroutine мы можем быстро выполнить процедуру перед переходом к следующему шагу. В результате был добавлен метод scanln; в противном случае код закончился бы, не успев показать все числа. Goroutines прост в создании и может быть выполнен в большом количестве. Вы заметите, что при выполнении этой программы горутины работают последовательно, а не параллельно.
Преимущества Goroutines перед потоками
Goroutines стоят мало
Goroutines стоят меньше, чем другие процессы. Размер массива составляет всего несколько килобайт, и он может расширяться или сжиматься в соответствии с требованиями программы, в отличие от потоков, размер стека которых должен быть определен и является постоянным.
Существуют мультиплексированные Goroutines
Существует очень мало потоков операционной системы, которые мультиплексируются. В программе с сотнями горутин может быть только один процесс. Остальные горутины передаются новому процессу операционной системы. Предположим, что какая-либо из goroutine в этом процессе застряла, например, когда она ищет вмешательства пользователя. Время выполнения управляет каждым из этих процессов, а нам, разработчикам, предоставляется четкий API для одновременного управления, при этом мы изолированы от этих тонких хитросплетений.
Goroutines общаться с помощью каналов
Goroutines общаться с помощью каналов. Предназначены для предотвращения возникновения ситуаций гонки при совместном использовании соответствующей памяти. Каналы можно сравнить с каналом, который используют горутины для взаимодействия.
Что такое каналы?
Две горутины могут взаимодействовать друг с другом и координировать свою работу через каналы. Эта программа будет постоянно печатать "ping". Чтобы обозначить форму канала, префикс "chan" сопровождается элементами, передаваемыми по каналу." В данном случае мы предоставляем строки. На канале сообщения отправляются и принимаются с помощью оператора. "ping" означает отправку сообщения "ping".
Канал используется для синхронизации двух горутин. Прежде чем попытаться отправить сообщение по каналу, маршрутизатор будет ждать, пока принтер не будет готов его принять. Для этого используется термин "торможение". При создании канала можно использовать второй параметр для функции make: c:= make (chan int, 1)
Направление канала
Мы можем определить ориентацию формы канала и параметры, чтобы он либо принимал, либо передавал. Например, знак метода Pinger может быть изменен следующим образом:
func pinger(c chan<- string)
C может быть отправлено только сейчас. Получение от c приведет к ошибке кода. Аналогично, мы можем изменить вывод на:
func printer(c string -chan)
Полуканал не имеет таких ограничений. Двунаправленный канал может быть передан процедуре, которая принимает только каналы "только передача" или "только прием", но не наоборот.
Как создать Goroutine?
Метод запуска горутины прост. Примените ключевое слово "go" к вызову функции, чтобы создать горутину, которая будет выполняться параллельно. Здесь мы собираемся создать горутину. Предположим, у нас есть программа, содержащая две функции: одна - функция приветствия, а другая - главная функция.
Когда мы создадим новую goroutine, код welcome () будет выполняться параллельно с функцией main(). Когда вы выполните эту программу, вы будете удивлены. Эта программа просто показывает текст основной операции. Что произошло с первой инициированной нами goroutine или новой goroutine? Чтобы понять, почему это произошло, мы должны сначала знать две основные особенности гораутинов.
- Функция goroutine реагирует мгновенно, когда мы создаем новую goroutine. Кроме функций, управление не полагается на goroutine, поэтому не ждет, пока она завершит свое выполнение. Выполнение передается следующему после функции goroutine блоку кода. Поэтому любые заданные параметры из goroutine не принимаются во внимание.
- Любые дополнительные программы должны выполняться одновременно с основной программой. Если основная горутина завершится неудачно, программа завершится, и никакие дополнительные горутины выполняться не будут.
Теперь вы понимаете, почему наш код не сработал. После вызова функции go welcome() управление было передано следующей строке кода, которая не дождалась завершения работы программы hello goroutine, и была выведена функция main. Главная goroutine умерла, потому что не было сценария для выполнения, не давая возможности hello Goroutine запуститься.
Мы вызвали технику sleep (time.sleep(1 * time.second)), чтобы приостановить работу goroutine на 1 секунду. Теперь функция приветствия () имеет достаточно времени, чтобы завершиться перед выходом из основной goroutine. Эта программа сначала пишет "welcome goroutine", а затем ждет одну секунду, прежде чем вывести главную функцию. Мы используем технику sleep в основной программе, чтобы приостановить ее на мгновение и дать возможность другим программам завершить работу.
Создание множества Goroutines
Мы собираемся запустить еще одну программу для создания нескольких горутин. Для начала мы можем создать две параллельно выполняющиеся горутины. Эти две горутины - горутина чисел[go numbers()] и горутина алфавита [go alphabets ()].
Гороутина числа остается на 250 мс перед печатью 1, снова отдыхает перед печатью 2, и так далее, пока не выдаст 5. Аналогично, алфавитно-цифровая горутина выводит на экран буквы от a до e, а затем ждет 400 миллисекунд. Наконец, основная горутина создает целые числа и алфавитно-цифровые символы и делает паузу, а затем основная горутина завершает работу.
Частые ошибки параллельного программирования
- Отсутствие синхронизации, когда это необходимо
- Использование времени. Sleep для выполнения синхронизаций
- Оставлять в гораутинах висящие значения копий типов из стандартного пакета синхронизации
- Вызвать синхронизацию
- Группа ожидания
- Добавлять метод в неправильных местах
- Использовать каналы в качестве закрытых завтрашних каналов, а не от последней функциональной отправляющей горутины
Заключение
В этой статье мы разработали программу, которая использовала ключевое слово go для запуска одной goroutine и нескольких goroutine, которые одновременно печатали целые числа. После запуска этой программы мы создали новый канал, который затем использовали для получения чисел в одной горутине и передачи их в другую горутину, чтобы они могли быть выведены на экран. В качестве последней демонстрации того, как запускать goroutine для ускорения работы приложений на многоядерных системах, вы одновременно запустили множество "печатающих" goroutine.
Как известно, goroutines - это способ более быстрого и эффективного выполнения задач. Это одна из процедур развертывания, предлагаемых AppMaster для улучшения функциональности вашего приложения. С помощью AppMaster даже люди с минимальными знаниями программирования могут выполнять задачи, которые было бы сложно выполнить с помощью ручного кодирования.
AppMaster это no-code платформа, позволяющая создавать мобильные и веб-приложения , а также бэкенд. Интересный факт: AppMaster создает бэкенд на Go со скоростью 22 000 строк в секунду, и вы можете получить доступ к исходному коду.
