[БЕЗ_ЗВУКА] А теперь давайте поговорим о каналах. Основная трудность при многопроцессорной разработке, то есть когда ваша программа использует несколько ядер процессоров или даже несколько процессоров, состоит в том, что вам нужно как-то их синхронизировать между собой и каким-то образом передавать данные между разными потоками. В Go для этих целей есть каналы. Каналы нужны, для того чтобы передавать владения данными в другую горутину. Как это работает? Смотрите, для начала нужно создать какой-то канал, канал создается конструкцией make, после идет ключевое слово chan и тип канала. То есть каналы будут тоже типизированы, в них можно класть только определенный тип данных. После этого, смотрите, я запускаю горутину, которая принимает на вход канал (in — это имя канала, chan int — это тип канала), вычитывает оттуда какое-то значение. Вычитывание из канала происходит посредством стрелки слева от канала, и печатается значение. Это отдельная горутина, которую мы запустили. В основной горутине мы кладет значение в этот канал. Кладется значение в канал, используя стрелку справа от канала. И затем мы что-то печатаем. Теперь давайте запустим это и посмотрим, как оно работает. Смотрите: сначала мы положили значение в канал, после этого дела мы вывели текст из главной горутины, после программа ожидает ввода от меня строки, и управление переключилось в горутину. Горутина получила значение из канала, и после значения что-то вывела. Но есть нюанс. Смотрите, такая конструкция make (chan int), она делает небуферизированный канал. Что это значит? Это значит, что, когда я кладу в канал какое-то значение, кто-то с другой стороны этого канала должен его прочитать. И если никто не читает, то горутина блокируется, до тех пор пока на той стороне не появится тот, кто вычтет это значение. К чему это можем привести? Привести это может к тому, что мы залочимся. Эта ситуация называется deadlock — когда горутина ждет, но не может дождаться. Давайте воспроизведем эту ситуацию. Смотрите, напишем что-то еще в канал. [ШУМ] Мы написали второе значение. И давайте запустим. Все плохо — рантайм ругнулся на то, что мы залочились на строчке 15, на отправке в канал. Давайте посмотрим, что происходит. На строчке 15 мы пытаемся отправить еще значение в канал. Но горутина, в которую мы указали, чтобы вычитать это значение, она выполнилась только один раз и завершилась после этого дела. То есть наша главная горутина, функция main, повисла на строчке 15 в ожидании, пока кто-то вычитает значение из канала. И все — и произошел deadlock. В данном случае нам повезло, потому что наша программа, она завершилась сразу с ошибкой. Но в случае если в deadlock попадут какие-то другие горутины внутри вашей программы, а другие горутины будут продолжать работать, которые будут выполнять совершенно другую работу, то может прийти ситуация, которая называется утечка горутин, то есть горутина залочилась и чего-то ждет, но никогда не дождется. Это приводит к утечке памяти, то есть это весьма плохая ситуация, Теперь давайте рассмотрим, каким образом вообще это можно избежать. Вроде бы не очень удобно иметь небуферизированные каналы. Каналы в Go могут быть буферизированными. Что это значит? Это значит, что канал может принимать не одно значение, до того как он залочится, а несколько. Осуществляется это если мы укажем значение буфера для этого канала. Смотрите. После запятой в конструкции make я могу указать 0 — это по-прежнему небуферизированный канал. Либо могу указать значение 1. 1 это значит, что я могу положить одно значение в буфер и, если я пытаюсь положить туда второе значение, то только тогда я залочусь и буду ждать пока там освободится место. Теперь давайте запустим нашу программу и посмотрим, что получилось. Смотрите, наша программа успешно отработала. Ошибки нет, и мы ее успешно завершаем. Это происходит за счет того, что на строчке 15 теперь наша программа не заблокировалась, потому что в нашем канале есть место, куда мы можем положить значение, не блокируясь. А теперь давайте рассмотрим, как можно работать в цикле канала. Вот перед вами программа, которая запускается, принимает канал. В данном случае это небуферизированный канал. И начинает печатать туда значения. После закрывает канал, а в главной горутине у нас есть конструкция, у нас есть цикл, который, используя range, просто итерируется по каналу, по тем значениям, которые туда приходят. Давайте посмотрим, как это работает. [ШУМ] Смотрите, мы записали что-то в канал, теперь мы залочились, управление получила главная горутина, она прочитала тут значения, и пошло дальше. И после этого, в конце, после 4-й итерации наш генератор, он завершил работу, управление вернулось в главную горутину, и она вывела значение. Давайте посмотрим, как это работает. Мы принимаем канал, в Go можно указать, при передаче канала в функцию можно указать, какого типа будет этот канал. Например, если я укажу просто chan int, это значит, что я в канал смогу и писать, и читать. Если я поставлю стрелку, это значит, что я смогу с этого канала только читать. Если я поставлю стрелку справа, это значит, что я смогу в канал только писать. Это удобно, чтобы не делать те операции, которые не ожидаются от этой горутины. И такого рода вещи проверяются на уровне компиляции. Смотрите: пишем-пишем-пишем, потом закрываем канал. Наш цикл должен когда-то прерваться. Когда цикл прерывается? Как раз таки закрытие канала ведет к тому, что цикл завершается. Давайте попробуем убрать закрытие канала. Смотрите, я убрал закрытие канала, генератор закончил работу, мы получили последнее значение, и теперь опять впали в deadlock. Почему? Потому что в канал in уже больше никто не пишет, а мы на строчке 20 все еще ждем оттуда значений. То есть конструкция close, она позволяет завершить цикл, которые пытается итерироваться по значениям, идущим в канал.
