Skip to content
Get App

Без этих знаний твой Go-вайбкод положит прод | Пакет sync изнутри

Разбор пакета sync в Go: внутреннее устройство Mutex, WaitGroup, RWMutex и Once, зачем нужна обработка паники в горутинах и как работает детектор дедлоков. Полезно для ревью кода, в том числе сгенерир

Key Takeaways

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

What the video covers

  • Агенты всё чаще пишут код, и разработчику важно уметь его ревьюить, особенно в Go
  • Пакет sync рассматривается как low-level примитивы синхронизации, для высокоуровневой координации предпочтительнее каналы
  • Примитивы sync нельзя копировать после использования, их нужно передавать по указателю
  • WaitGroup реализуется через счётчик и ожидание; разбирается обёртка с методами Add, Done и Wait
  • Метод Go у WaitGroup добавлен недавно и упрощает запуск горутин с корректным учётом счётчика
  • Паника в горутине без перехвата роняет всё приложение; WaitGroup прокидывает панику дальше
  • Рантайм Go содержит детектор дедлоков, который выбрасывает панику, когда горутины ждут друг друга бесконечно
  • Под капотом примитивы синхронизации используют семафорную таблицу с шардами и сбалансированными деревьями, хранящими очереди ожидающих горутин
  • Mutex разбирается через спиннинг, режим starvation и очереди; описываются недостатки спинлока
  • RWMutex и Once показаны как типичные задачи с собеседований, включая паттерны блокировки на время выполнения функции

Answers

Questions about this video

Почему в пакете sync не рекомендуется копировать примитивы?

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

Что произойдёт, если паника возникла в горутине, запущенной через WaitGroup?

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

Как Go обнаруживает дедлоки?

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

Full Transcript — Download SRT & Markdown

00:00
Speaker A
Привет. И агенты всё чаще внедряются в нашу жизнь. Мы уже больше ревью код того самого агента, нежели пишем код руками.
00:09
Speaker A
И особенно это актуально для таких языков, как Го, где язык и его простота располагают к этому. В этом видео я подробно разберу пакет Syn, его внутреннее устройство и нюансы, чтобы ты мог корректно и безопасно ревьювить тот самый код с генеринной моделью и смело
00:28
Speaker A
катить его в прот. Приятного просмотра. Да, и здесь есть ещё такие немножко мемы. Это как реализовано? Мы по адресу находим шарт, а в этом шарде уже ищем linkнлист. Взяли у вот правой части у читателя отжали один битик. Сейчас
00:42
Speaker A
проходит всё, катим в прод работаем. Assignment to enter in map. What? Как так получилось, непонятно. Spinlock - это как раз-таки почему спин, потому что мы типа крутимся вот в этом цикле и пытаемся поменять санлока на лок.
00:53
Speaker A
Специальные многопоточные инструкции, чтобы потом изменения одного ядра были видны другому ядру. Должен быть выгадан.
00:59
Speaker A
Он куда-то пропал. Давайте допишем, да, допишем выгадан. Так вот, эта тема, которую мы сейчас обсудим, это прямо множество задач с собеседований. Есть разные соусы на собеседованиях, под которым это подают.
01:11
Speaker A
Что такое дерево? Дерево - это так граф граф, но от этого легче не стало, наверное. Как работает гошны мьюкс?
01:17
Speaker A
Пошло мясо. И мы говорим: "Всё, это игрутины тикет один, всё, она сейчас пойдёт следующая. Если этот счётчик меньше нуля, значит сейчас есть писатель. На момент go 126 можно написать вот так. И будет эквивалент.
01:30
Speaker A
Первое, что должен человек показывать, данная нагрузка. Из этого как бы я могу б менчchмарк сделать почти любой понимание атомиков, да, то есть что дёшево, что дорого и перекладывать жесоны, когда примут на работу. Сейчас у нас такой вкат. Мы сейчас будем писать
01:43
Speaker A
свои собственные примиссивые синхронизации многопоточно и потом из этих примитивов строить более сложные программы, более сложные вещи. Вот я предлагаю начать с вегруппы. Вейтгруппа.
01:52
Speaker A
Давайте, что у нас, какая проблема? У нас есть, значит, код, который запускается, запускает грутины, и надо каким-то образом дождаться всех грутин, что давайте заведём просто счётчик и будем его инкрементировать. Либо, понятно, можно вот так сделать, очень важно здесь для примера.
02:09
Speaker A
И в конце дикремитировать. И, соответственно, будем в форике ждать, пока счётчик не станет ноль.
02:15
Speaker A
А пока ждём, будем отдавать управление рантайму. Давайте возьмём и, соответственно, вынесем всю вот эту вот историю в обёртку. В обёртку. То есть сделаем структурку Group, у неё будет state. И у нас будет такой интерфейс.
02:31
Speaker A
Будет add добавлять какую-то дельту, дан будет делать декремент и ве будет дожидаться. И вот у нас такая вот получилась история. Вот. Ну и дальше, что мы сделали? Мы такие вот, давайте возьмём, добавим такую крутую функцию GO, которая будет сначала доба
02:44
Speaker A
добавлять, потом запускать в грутинюю функцию и в конце добавлять, то есть делать декремент. Вот и такая функция go. У нас та очень красивый получается код, что мы как бы запустили крутинки вот так вот, да? И вот vве вызвали в конце.
02:58
Speaker A
И на самом деле есть встроенная такая штука в язык вот, которая называется друг. Находится она в пакете син. Давайте, что такое пакет си?
03:09
Speaker A
Пакет S. он даёт возможность предоставляет базовые примитивные синхронизации например втек. Значит, что нам здесь говорят? Нам говорят, что как бы кроме вейт гругруппы и синкуанса желательно использовать только для каких-то lowлеevel историй. То есть это как бы условно считается уже
03:30
Speaker A
высокоуровневая история, то есть лучше, чем атомиic, но всё ещё low level, то есть всё ещё пакет син считается low.
03:37
Speaker A
Вот. И, соответственно, говорят, что вот лучше всего использовать каналы для более выскорнённой синхронизации. Мы их тоже будем обсуждать подробно. Вот. И нам говорят, что мы не должны копировать значение типов из этого пакета, потому что вот спроектировано так, что это не
03:54
Speaker A
подразумевается. Сейчас хорошему всегда создавать по по указателю эти все истории, то есть или продумывать дизайн, чтобы никогда не копировались эти структу. Если я возьму, передам в какую-то функцию фу, например, вот так вот сделаю, да, то как бы мне
04:10
Speaker A
даже подсветит, что потому что внутри счётчик он будет именно на копии, да, основан не исходу.
04:19
Speaker A
Вот и такая вот такой примитив squad group, то же самое, что и у нас буквально, то есть семантика один в один, которую мы написали сами. У неё вот есть метод add, и туда можно передать что-то. Вот если передать число
04:32
Speaker A
отрицательное, давайте специфическая история пакета S и пакета Reflection Reflect тоже, что если вы сделали что-то не так, вам вернут не ошибку, ничего, вам вернут просто панику в лицо. Вот такая специфическая история пакета сил.
04:44
Speaker A
О'кей. Какие такие кейсы можно посмотреть? Давайте просто как бы когда просто покажу, когда кидает гругрупа панику. Например, ветгруппа кидает панику, если у вас вызван вейт, и вы одновременно вызвали либо дан, либо это не предполагается. Предлагается, что как бы у вас, да, видно, что паника, что
05:07
Speaker A
before это такое ограничение библиотеки. О'кей. Что ещё? Что ещё? Если, например, опять же, это неправильно так дела, да?
05:23
Speaker A
Как правильно? Какое взаимодействие прозмевается? Что создали группу, запустили рутин, они что-то сделали. Опять же, вот этот метод го, он появился как разтаки на самом деле недавно. Вот.
05:34
Speaker A
Да. И здесь есть ещё такие немножко мемы. Короче, это было изза чего сделано? Давайте расскажу. То есть раньше этого куда не было. Если у вас запускается отдельная рутина и вот эта функция F паникует, то у вас умирает всё
05:47
Speaker A
приложение. То есть какая такая вот отчислительная особенность. Го, что если в гарутине не поймать панику, то у нас приложение просто завершится. И что сделано здесь? Здесь эта паника ловится и прокидывается дальше, потому что если вдруг есть какой-то обработчик дальше, то как бы он
06:04
Speaker A
поймает. Вот. И здесь как раз-таки это сделано, потому что представьте, у вас какое-то приложение, например, там ваше приложение, и вы такие берёте и запускаете гурутинку вот так вот, да, где-нибудь в в недрах обработки запроса в бизнес-логийке через там какой-нибудь
06:20
Speaker A
нет слой ещё отдельный. У вас случается паника, такое бывает, и у вас умирает весь пот.
06:28
Speaker A
Поэтому такой вот добавили протекшн этой истории. Как работает вся вот эта история? нас с вами можно запустить ротину через тгруппу дождаться её выполнения. Вот при этом как бы если мы будем дожидаться здесь вот и параллельно где-то что-то ещё запустим. Понятно, что такое
06:51
Speaker A
параллельность конкаренсия синхронность, мой термин тоже обсудим чуть позже. Пока я просто рассказываю интуитивно для понимания, что это у нас будет паника. Здесь же какой нюанс, да? Если мы сначала запустили, дождались, потом ещё раз запустили, дождались, проблем не будет. То есть это
07:06
Speaker A
нормальное использование с точки зрениягруп. Здесь всё хорошо. Значит, а что ещё? Да, понятно, что если мы, например, возьмём и там запустим сделать дан, да, ещё что-то, то у нас будет дедлок. Мы сегодня говорим про runтайм. Отличительностью, особенностью go является то, что там встроен так
07:26
Speaker A
называемый deadlock detection. То естьтай может понять, когда сейчас никакую гарантину запустить нельзя, они чего-то ждут и выкинуть панику, да, что извините, как бы у нас проблема на что такое SEM Aquire Group, мы тоже это подробно обсудим. Там реализация этого
07:45
Speaker A
механизма, используется такое дерево. То есть там каждый примитив синхронизации, а он на самом деле мапится. Вот кто делал DZ, там была ссылочка на сема, да, там ещё вот был история с флс шерингом, да, то есть случается, на самом деле получается, что у каждого
08:04
Speaker A
примитиво сихронизации на самом деле под капотом, а есть вот сейчас чикну есть вот такая вот штучка такая sim table, то есть на самом деле там как работает по адресу этого примитива мы выбираем некоторый шард и дальше в этом шарде хранится сблансирова дерево,
08:25
Speaker A
но которого являются линктлистами к этому приветивой синхронизации. То есть там условно есть у каждой ветг группы есть там определённый, значит, свой своя очередь тех, кто там, допустим, ждёт или тех, кто использует. Сейчас мы это тоже подроб пока вот просто для понимания,
08:43
Speaker A
да, там капотом есть такая структура данных, которая позволяет нам не просто в цикле крутиться, а более умно дожидаться. Мы тоже это сегодня обсудим. пока не партийсь, пока всё всё окей. Вот. Ну понятно, что если мы забудем какой-то, допустим, сделать декремент, да, то у
08:58
Speaker A
нас будет deadlock. Деadлок - это тоже мы будем подробно термины обсуждать, но пока для нас это вот когда у нас взаимная блокировка, некому исполняться, все друг друга ждут, непонятно, что происходит.
09:10
Speaker A
Вот. И то, что сказано здесь, что в нельзя копировать. Понятно, что если вы, допустим, возьмёте, создадите группу, сделаете инкремент, передадите функцию, которая скопирует здесь группу, и здесь сделаете декремент, то этот декремент будет относиться к копии. Поэтому здесь будет тоже дело, что на самом деле вот
09:27
Speaker A
этот декремент, он относится не к этой вид группе, а вот к её копии. Копировать не стоит.
09:35
Speaker A
Копировать не стоит. Хорошо. Ну давайте всё-таки к интересности. Как же реализована на уровне рантайма вся эта история? Вот давайте я как бы тут такая реализация сначала для Я здесь взял реализацию рантайма, просто вынес всякий мусор, чтобы вас не
09:54
Speaker A
травмировать на первом эта шаг. Сейчас мы посмотрим, а потом посмотрим на реальную реализацию. Как она работает. Смотрите, они используют такой вот хак, который мы будем часто применять в многопоточном программировании. А на самом деле он очень сильный. Очень сильный.
10:11
Speaker A
И его стоит запомнить. А, смотрите, в чём проблема вейт группы. Нам надо уметь сразу хранить две вещи.
10:24
Speaker A
Это количество сейчас ожидающих грутин и сам счётчик. Те, зачем нам хранить количество ожидающей грун? Давайте сперва давайте сутим, как реализовано. Я потом расскажу идею. А там есть вот такой вот счётчик 64 бита. Как он работает? Смотрите.
10:46
Speaker A
А даю сейчас, а значит, вот этих и 32 вот этих. Этот счётчик развит на две части по 32 бита. Вот в этих битах хранится сам счётчик. Вот здесь вот сам счётчик. В этих битах хранится сам счётчик. Прямо вот беребиты. И вот здесь
11:08
Speaker A
хранят счётчик. А в этих битах хранят количество рутин, которые сейчас вызвали вейт. Зачем? Чтобы потом их разбудить. То есть там более умная история, не как вот у нас было в цикле бесконечном.
11:23
Speaker A
А вот и на самом деле в го Давайте, ладно, я скажу про это. Давайте потом сейчас пока просто, чтобы не травмировать. Давайте эти биты для счётчика, эти биты для количества ждущих. суммарно. Вот у нас есть поле statт и у нас есть это поле SEM. Вот это поле
11:45
Speaker A
SEMA, оно как раз-таки позволяет нам вот в этой прекрасной структуре данных получить linked listст ожидающих рутин для нашей вейгруппы. На самом деле эта штука позволяет получить а шарт, то есть дерево сбалансированное. А уже в этом дереве мы по адресу находим линклист.
12:06
Speaker A
То есть вот мы по адресу, видите, вот root for, мы по адресу находим нужную нам шарт. Почему так? Потому что понятно, если у нас было бы, то есть там задача какая? Нам нужно уметь по адресу группы находить её очередь. Это как
12:20
Speaker A
реализовано? Мы по адресу находим шар, а в этом шарде уже ищем linkли list. Этот шарт является на самом деле забалансированным деревом.
12:28
Speaker A
И как работает дальше? Работает следующим образом. Давайте, как работает? Нам дают дельту. Мы что делаем? Нам нужно получить счётчик. Да тебе ты.
12:39
Speaker A
Это тебе ты. Мы что делаем? Мы говорим: "О'кей, берём наш вот этот счётчик, сдвигаем его на 32". Почему? Потому что, ну, нам нам дали, грубо говоря, вот давайте нам дали, грубо говоря, нам дали вот такое число. Нам дали вот
12:54
Speaker A
такое число. Прибавить один. Нам, чтобы прибавить один, нужно вот эти биты сдвинуть налево. Вот мы их сдвигаем налево и прибавляем к нашему стейту.
13:04
Speaker A
Прекрасно. Дальше вот мы достаём две переменные. Переменная V. Что такое переменная V? Переменная V - это наш счётчик. Вот эти вот биты, наш счётчик.
13:14
Speaker A
Как мы его достаём? Нам нужно вот эти биты сдвинуть вправо. Ну то есть право месяц, понятно. Брать вот эти. Вот мы берём, сдвигаем вправо на 32. То есть вот это V - это количество как раз-таки счётчик. Это что такое W? Это waiters. Количество
13:30
Speaker A
ждущих горутин, то есть рутин, которые вызвали вейт, да? Как мы получаем? Мы просто castм state в un 32, то есть отсекаем вот эти вот старшие биты и получаем наших количестве ждущих. Прекрасно. У нас есть две переменные. То есть это идея очень
13:44
Speaker A
такая тонкая, что мы в одной шестичетырёхбитной переменной храним сразу два счётчика, потому что задача изменения атомарно двух счётчиков в многопоточном программировании не такая простая. На самом деле есть там называется КОС2, КСН. Это не очень просто. Вот это очень тонкая идея
14:00
Speaker A
хранить в одном счётчике сразу множество данных. Такая очень хорошая. Дальше есть некоторая проверка, что если у нас счётчик вдруг отрицательный какая-то проблема, давайте, что этот делает? Он говорит: "Если счётчик больше нуля, то есть ещё пока не не нужно никого
14:13
Speaker A
разбудить, кто ждёт? Или или если у нас никто вообще не ждёт, тогда просто ретёр, всё забиваем, ничего не нужно делать". А вот если кого-то нужно будить, тогда уже идём наши дела делать грязные. Что мы делаем? Мы говорим: "О'кей, нам нужно что сделать? Нам нужно
14:31
Speaker A
рутин, которые сейчас ждут, разбудить". Для этого что происходит? Для этого в таком вот цикле мы бежим так вот по количеству наших ждущих и вызываем специальную функцию Runtime 7 relas.
14:43
Speaker A
Передаём указательно вот эту переменную сема и говорим: "Мы хотим handof, это мы обсудим потом". Skipф frames нужно, чтобы сказать, что мы хотим стрейс полностью весь, ничего не скипать. Вот вопрос следующим. А какрантайм ставит в очередь те самые рутины? Вот что
15:00
Speaker A
происходит в вейте. Смотри, что как вейт работает. Мы приходим, говорим: "Хотим подождать". Говорит: "О'кей, достаём стейт, достаём из стейта наш счётчик".
15:08
Speaker A
Как мы его достаём? Опять же берём вот эти вот питы, которые вот. А дальше что происходит? Мы говорим, если сейчас счётчик ноль, просто выходим. Всё, ждать никого не нужно. Иначе, что мы делаем?
15:19
Speaker A
Видите, вот эта идея, которую мы обсуждали в прошлый раз, помните, вот с максимумом вот бесконечный цикл, активное ожидание. Тут ровно такая же идея. Смотрите, берём, крутимся в бесконечном цикле и пытаемся сделать каз. Каз какой? Мы хотим поменять значение вейтеров. Мы хотим сделать плюс
15:35
Speaker A
один вот сюда, да? Вот смотрите, что происходит. Мы берём и пытаемся сделать state state + о. То есть мы пытаемся вот в нашу правую часть, ну, буквально вот сюда, так скажем, да, вот в это число записать плюс одного вейтера, плюс один
15:47
Speaker A
ждущий, да, и если получилось, тогда мы вызываем runtime SEM acquire weight group. Передаём вот наша сема. Это просто адрес и там некоторы прове некоторые варианты.
15:59
Speaker A
Вот как работает эта очередь Runime SEMQ group и Runime 7 relas. На самом деле она работает на основании вот этой штуки сема. Что такое сема? Реализовать очередь ждущих горутин надо каким-то образом. То есть делать, как мы делали с
16:14
Speaker A
вами вот здесь вот просто в цикле крутиться. Так тоже можно, но это неэффективно. Поэтому что говорят?
16:21
Speaker A
Говорят: "Давайте мы сделаем по-умному". Вронтайме есть и для Мьютекса, и для йгруппы, и вообще для всех принцих организаций такой вот, можно сказать, SDK. SDК, то есть такой вот фреймворк для ожидания. Что в нём хранится?
16:33
Speaker A
Смотрите, в нём хранится, помните, падинка ещё, да? Вот как разтаки для флшеринга. Я рассказал, зачем ну как как работает. Приходит привести синхронизации, говорит: "У меня есть вот такой адрес, вот такой адрес". Дальше по этому адресу что происходит? Мы вот в
16:45
Speaker A
этом самом вот из этих вот шардов, да, их количество ограничено, то есть мы выбираем шард, в котором расположена потенциально наша очередь ждущих горутин, нашли. Как мы выбираем? Вот по такой схеме. Берётся адрес, сдвигается вот внутри, потом берётся, понятно,
17:02
Speaker A
остаток поделения на sim table и, соответственно, дальше получаем root, то есть получаем root нашего дерева.
17:09
Speaker A
Дальше в этом дереве у нас хранятся link листы. То есть каждая нода этого дерева, она является линк-листом. То есть у нас буквально как работает каждая такая нода - это вот weight link. То есть видите, они как бы итерируются по вот этим
17:22
Speaker A
судогам. Видите, это вот судок. Они по нему итерируются в дереве. Это нод дерево. А в каждой ноде есть вот этот weight link. Это как раз-таки list ofру, то есть это буквально link list ждущий.
17:33
Speaker A
То есть у нас есть просто дерево, мы берём, как ещё раз, давайте, вот у нас есть просто количество зашитое в коде шардов. По адресу получаем шарт. В этом шарде у нас есть дерево. В этом дереве находим линклист. И дальше в этом
17:46
Speaker A
линклисте у нас есть очередь ждущих грутин. Да, когда мы в нашей ведрупе вызываем в вот делать когда add, да, мы берём потом в конце, когда нужно всех будить, просто вызываем релиз, который берёт из этого вот линклиста, достаёт грутинку и
18:00
Speaker A
её запускает. На самом деле оно можно запустить может либо сразу, либо поставить в очередь. Там есть два варианта. Хнoв, как раз-таки оно отвечает за то, сразу запустить или подождать. То есть либо сразу на тех же ресурсах, либо же в очередь поставить. А
18:14
Speaker A
когда приходит вей и говорит: "Я хочу подождать". Да, что происходит? Вызывается вот Rime Simquire W group. И мы говорим: "О'кей, теперь мы берём и ждём в линклисте. И вот по этому адресу мы этот linkнлист понимаем". Да, то есть
18:25
Speaker A
это задачка по этому адресу понимать linkли list ожидающий крути. Какая реализация? Вот. И на самом деле ик такой же идее построен, и все остальные примитивы тоже. Кроме Синконда там есть небольшой хак. Там для них вот как раз-таки отдельно есть лист, которые я ниже
18:41
Speaker A
показал. Для них там отдельно сделали антифалисты. Вот. Давайте чуть-чуть мяса. Чуть-чуть мяса маленько. Маленько мяса. Значит, как сделан реальная вейт гругруппа? Здесь всё то же самое, что я вам рассказал, за исключением двух вещей. А вещь номер один. В GoОO недавно добавили пакет как
19:02
Speaker A
раз-таки S-теest. И для этого что сделали? Взяли у вот правой части у читателя отжали один битик. Этот битик он используется для сингтеста. Битик.
19:13
Speaker A
Вот. Соответственно, теперь там отдельно вот этот бит его используют для син-теста чтобы например понимать правда ли, что сейчас рутина запускается в этом бабле. И второе - это для рейс-детектора есть некоторая разметка.
19:26
Speaker A
Вот вот здесь вот там условно. Надо же как-то рейдетектору понимать, это вы у вас гонка в коде или вы вызвали переместить синхронизации. Поэтому тут есть разметка, собственно говоря, для рездетектора. А в целом всё вот так, как я показал, буквально один в один. Те
19:40
Speaker A
ровно такая же и код ровно такой же. Хорошо, давайте поедем дальше. Это это это если что мы разобрали для понимания один из двух самых простых примитивов, которые есть. Other than on and we group types. То есть это как бы два самых
19:53
Speaker A
простых. Теперь после внедрения тестового битика ещё меньше рутин можно запускать или это только вейт? Это только вейт. Да. ещё, ещё меньше ждущих, но давай будем честны, как бы количество ждущих рутин вряд ли когда-то превысит, ну, как бы это прямо какая-то мясо. То
20:10
Speaker A
есть, ну да, теперь у нас потенциально отжали битик у вейтеров. То есть теперь потенциально возможно, если был у нас было такое огромное количество вейтеров там, да, вот то, ну, понятно, это вряд ли такая история, поэтому спокойно отжали и всё. Давайте перейдём к
20:25
Speaker A
следующему превитиву, а именно к синкнсу. Что такое син? С точки зрения там C++ это STD Ones. Дальше в расте есть вот такая штука. Что это такое? Это некоторый примитив, который предоставляет следующую гарантию. Мы хотим исполнить функцию f один раз при
20:40
Speaker A
этом. При этом. Понятно? То есть функция do её могут вызвать разные горутины в разных местах в любое время. Но мы хотим гарантировать такую вещь, что функцию f вызовут только один раз, даже если мы придадим разные функции вот сюда. То есть мы гарантируем, что вызов
20:56
Speaker A
функции do он ровно один раз исполнит какую-то f, которую в него передали. Как это написать? Смотрите. Ну, банальная история, да? Давайте возьмём, заведём флажочек.
21:05
Speaker A
А, дан буля. Если сейчас compare swop, помните, я рассказывал, что можно бесконечность потоков привести к консенсусу. Давайте сделаем. Если у нас fфse на true, тогда возьмём и на самом деле можно тут даже каст на самом деле можно и не нужен. можно было сделать
21:19
Speaker A
какое-нибудь вообще простое решение, типа, делая же без такого мощного примитива можно, можно там при желании сделать что-то типа там это один, да, и проверять, что как бы мы первые, кто этот экменя там можно зациклить, конечно, но это простая реализация
21:35
Speaker A
это просто вариация некода можно её тоже мы делаем кприсп с фоса на true. Если успешно первый раз, то F. Всё, давайте в чат небольшой экскурс. Напишите, пожалуйста, в чат, кому такая реализация нравится. Кто считает, что это хорошая реализация. Плюсик в чат или минусик
21:49
Speaker A
давайте, если не нравится. О, Алексею нравится. Супер. А, хорошо. Смотрите, давайте теперь напишем небольшой код. Я напишу многопоточную мапу. У меня в ней будет, будет пока что какой-то непонятный. Ну, какая-то блокировка непонятно какаятое, но просто пока и значение. Дальше у меня будет такая
22:07
Speaker A
штука. Я хочу сделать такую инициализацию, как, допустим, сделано в листе. Есть такая в листе встроена в гошном.
22:14
Speaker A
Инит, типа ленивая инициализация. Вот давайте тоже сделаем такую ленивую инициализацию. То есть не сразу создадим вот хранилище, да, а при первом вызове эда. То есть мы хотим, чтобы при первом вызове Эда у нас вызвалась функция init и она уже создала, собственно говоря,
22:29
Speaker A
нашу мапу. Прекрасно. То есть смотрите, мы берём, вызываем и понятно. Мы хотим просто первый раз, когда мапу используют, её проициализировать. Только йди инициализация, всё нормально. Вот. И потом, когда уже проинтелизировали, тогда уже как бы берём под блокировочкой, да, и прямо вот так
22:44
Speaker A
сделал допустим излог а m значит mx функция, да, которая там под блокировочкой. Давайте, давайте пока считать, что это какая-то уникальная история, что вот можно только вот одна рутина может только этот код исполнять.
22:58
Speaker A
Давайте пока так считать, пока мы не обсудили блогеров. А, о'кей, вроде всё логично. Интилизируем один раз, используем вот это do. Да, всё прекрасно. И у нас здесь будет вызваться F.
23:10
Speaker A
Давайте напишем тест. Тест написали. Всё там даже условно стого рутин запустили. Обе там все делают какой-то там и делают в это.
23:20
Speaker A
Отлично. Берём, запускаем тест. Тест проходит. Всё, катим в прот. Давайте на всякий случай больше итерации когда что там. Точно, точно, точно. Всё, классно, отлично.
23:30
Speaker A
Прекрасно же, согласитесь. Ну давайте представим, что у нас прямо большое приложение. Мы прямо много там что-то делаем. У нас там, ну, часто случается такое, что рутины функция, допустим, в ней там под капотом нас прервали, так бывает, да? То есть, допустим, какое-то
23:43
Speaker A
количество сделаем тайм сп небольшой. Ну, только представим, что это просто нас случайно так получилось, что значит гошные runтайм при вызове функции make, это же может быть кол по-хорошему, да, попросить его и память нас могут прервать. Такое бывает. Вот запустим
23:59
Speaker A
тест ещё раз. Assignment to entry in map. Как так получилось, непонятно. А на самом деле случилась такая проблема, что у нас рутина одна зашла вот сюда, вот на этом месте, начала эту строчку исполнять, не закончила, пришла другая рутина, увидела здесь, что ага, всё
24:19
Speaker A
проинтилизировано и пошла менять, но ещё вот эта грутина не закончила создавать. Мы сталкиваемся с проблемой, что теперь нам не просто нужны какие-то многопоточные примитивы, а нам нужно не просто какие-то многоточные инструкции, как мы вот в прошлый раз обсуждали, а
24:33
Speaker A
нам теперь нужно как-то научиться их готовить правильно, чтобы всё работало. На самом деле для этого есть ещё формализм. То есть если мы зайдём в заменим наш вот самодельный на настоящий, да, на настоящий син, то оно будет работать. Оно будет работать. Тест будет
24:53
Speaker A
работать. Почему? Потому что на самом деле это изначально зашивается в его То есть есть model. У меня есть доклад даже про эту историю, что вот мы говорим, что у нас return from f связана таким математическим отношением бинарным с
25:08
Speaker A
ретрном функции ones do. То есть гарантируется, что функция f должна всегда завершиться до завершения ones do. И вот как раз-таки эта гарантия, она позволяет нашу проблему решить.
25:22
Speaker A
И вот такой примерчик, что как бы, да, можно иметь там все многопоточные инструкции. Всё, мы там уже начиная с мы уже что мы буквально мы начиная там с ассемлера, начиная с операций, да, давайте вспомним, мы там буквально писали сами атомики свои, мы уже как бы
25:35
Speaker A
пришли к тому, что нам нужно думать о том, а как правильно написать. Просто что за использовать, а как правильно написать. Есть фреймворк, который позволяет проверять так называемую линеризуемость. Давайте пока я это скипну сегодня, потому что это будет отдельно у нас история большая долгая
25:48
Speaker A
про то вот как вот эти вот отношения проверять, которые писанысь. Посмотрим, пройдёмся на гарантии того или иного примитива. Отдельно я это скину. Это прямо такая адванс штука. То есть вот эти все отношения в них разобраться. Там есть разные sequence before и давайте
26:03
Speaker A
разберёмся, как на самом деле работает гошны си работает он следующим образом. Фича. На самом деле здесь даже есть но, что это некорректная имплементация, настолько даже видите. Как работает син? Ему дают функцию F. И есть так называемый fast pass. Что такое fast pass? Если уже мы
26:24
Speaker A
знаем, что эту функцию до этого никто не исполнял, тогда заходим в dos. То есть такой это частая история в гона встречается довольно часто. Например, похожие история есть в функции, которая конверсирует.
26:38
Speaker A
Есть такая форматы, да? Вот здесь тоже типа, если это какое-то маленькое число, тогда давайте просто возьмём и готовую табличку зашьём. То есть в го часто такое делают. Fast P, если что-то можно быстро сделать для маленького какого-то там значения или в целом сейчас, то это
26:52
Speaker A
дело. Проверяем. Если сейчас надо как первый вызов, тогда заходим в slow. А вс берём блокировочку, опять же, мы ещё не обсуждали, но на самом деле под капотом это будет там сложно сделано, как бы, но можно думать, что там используется
27:07
Speaker A
comparing swop, то есть такой вот флажочек. Правда ли, что Рутина сейчас заняла это? Да. Вот делаем косоп самый простой к спинлоlock называемый. И дальше под этим мьютексом уже проверяем.
27:18
Speaker A
Если всё ещё надо, почему? Давайте, зачем нужна вторая проверка? Кто понимает? Вот мы тут проверили и потом ещё раз тут проверили. Зачем? Вот тут проверили, что нужно ли сейчас функцию исполнять. Потом пошли сюда и взяли блокировку. И ещё раз провели. Зачем ещё
27:31
Speaker A
раз? Потому что что может быть? У нас одна грутина уже зашла сюда, взяла блокировку, а другая её отпустила и уже флажочек поменяла. Есть две грутины.
27:40
Speaker A
Одна грутина находится, давайте, она находится вот здесь. Другая грутина находится вот здесь. Она исполняет функцию плажочек всё ещё фолс, он пока ещё не трогает. Давайте это будет G0, это будет G1. Дальше что происходит? G0 заходит вот сюда, пытается взять блокировку, не может,
27:59
Speaker A
потому что G1 её уже держит. G1 завершает функцию F исполнять, идёт вот сюда, ставит флажочек в true и выходит.
28:08
Speaker A
G0 берёт блокировку и без этой проверки пошла бы ещё раз исполнять функция. Поэтому нужна вот именно проверка, потому что могло быть такое, что у нас вот такая ситуация, да, вот эта вот карусинка вот на этой строчке, эта грусттинка на этой строчке. Вот поэтому
28:20
Speaker A
нужна ещё проверка. Дабл, да, вот Олег уже, Олег уже, да, Олег уже накидывает douблчек log, да, это на самом деле паттерн, то есть чеклогчек называют ещё как бы точно. А почему типа не сделать сначала здесь блокировку, а потом пойти?
28:33
Speaker A
Потому что это оптимизация, то есть этот fast pass недаром называется, видишь? Slow slow pass. Вот это slow pass это fast pass, потому что если ты сразу возьмёшь, это дорого. И на самом деле у Синкнса есть функция, о которых мало кто
28:45
Speaker A
знает. Есть в пакете S функция Once Fun, которая позволяет передать функцию. Эта функция возвращает функцию, а в эта функция лямбда создаёт под капотом син и уже в ней как раз таки там всё делает.
28:56
Speaker A
Короче, это просто сахар, чтобы не создавать синми. Прикольно. То есть такая более фэннси штука. Можно, допустим, инит какого-то конфига, да, и можно просто вызвать инит, то есть не создавать руками синс, просто сахар над этим асинтетический.
29:11
Speaker A
Вот. И здесь есть тоже приколы. Если мы, например, исполнили, то хотим взять и репанику сделать, чтобы получить полный.
29:18
Speaker A
Вот. И на самом деле есть такая же штука для две модификации. Модификация первая - это once value. Это то же самое, что здесь, только ещё умеет отдавать какой-то результат. Допустим, функция, которая возвращает что-то. На самом деле, буквально наш с вабикосенсус. И
29:31
Speaker A
ещё более продвинутая версия - это функция, которая возвращает два значения свой. То же самое, только теперь два значения возвращать. Вот такая вот песня. Такая вот песня про синкн. Давай обсудим с вами часть с мьютексом. То есть как написать базовый. Смотрите, как
29:46
Speaker A
пишется базовый. Это спинлок, то есть это блокировка, да, блокировка. Там огромное количество теории, есть разные блокировки, там разные гарантии. В го используется гибридный подход, но на самом деле у Мьютекса есть прямо формальные свойства, которые можно обсуждать, насколько честно поток
30:03
Speaker A
получает очередь. Там есть разные тоже градации. Подюту всё очень просто, на самом деле. Lock and log, но там под капотом есть некоторые формальные свойства, которые отдельно отдельно можно рассматривать. Идёт углубление именно в Как написать базовый тук.
30:16
Speaker A
Смотрите, вот мы хотим написать базовый muteкс. Тут, если что, можно было на самом деле вот так сделать. Пока у нас compare swap. То есть мы что делаем? Мы заводим счётчик state. У нас есть unlock и loged. Пока у нас счётчик наша ротинка
30:28
Speaker A
пытается счётчик сдвинуть с нуля на единичку, да? А как только она, соответственно, его сдвинула с нуля на единичку, то нам вернул кастру, и мы вышли. Иначе мы просто ждём. А как работает? Мы берём и делаем, значит, просто unlocked. Здесь сюда записываем
30:44
Speaker A
ноль. завели счётчик какой-то и на кассе сделали просто блокировочку, то есть заняли его и на анлоке его отпустили.
30:52
Speaker A
Важно, что именно здесь нужно именно вот такой делать. Как бы другого и нельзя, потому что у меня обёртка томика. Если сделать условно вот так, то эта операция немного поточная, поэтому понятно, может быть те проблемы, которые мы обсуждали.
31:05
Speaker A
Самый простой, который можно написать, называется ск. И вот кто очень внимательно делал домашнее задание с XV6 система, мог увидеть, что там на самом деле буквально спинлок упоминается входе. Вспейсе можно найти упоминание спинло. Почему спин? Потому что мы типа
31:23
Speaker A
крутимся вот в этом цикле и пытаемся поменять санлок и налог. Это такое название, известное название. Это один из первых именно прикладных мьютексов.
31:31
Speaker A
На самом деле были ещё до этого и теоретические всякие вещи, типа Петерсона или Лампорта. Вот. Но они настолько.
31:39
Speaker A
Ну то есть лампортно-прикладной ещё гибридный вариант. Вот мы пока с вами что сделаем? Вот мы возьмём сейчас и попробуем на базе вот как раз-таки этих этого интерфейса посмотреть, как в Go принято с ним работать. Считаю это окей.
31:55
Speaker A
Кe, то есть смотрите, мы сначала что сделаем? Мы сначала поймём, то есть понятно, в Go есть тоже к там такая же у него семантика, то есть есть log, да? есть, соответственно, unlock и на самом деле есть интерфейс Sloger, который как
32:10
Speaker A
разтаки про это. И мы сейчас что сделаем? Мы сначала поймём, какие есть паттерны использования в горе, а потом разберём внутреннюю структуру. Может это будет гораздо проще понять потом, почему так сделано, а не иначе. Итак, первый паттерн, который часто можно встретить в Го, и он
32:31
Speaker A
является довольно частым, это когда мы берём, заходим в какую-то функцию и, соответственно, хотим взять блокировку на всё время исполнения этой функции.
32:44
Speaker A
Вот в Го есть такой паттерн, то есть берут, соответственно, блокировочку и пишут в дефёре сразу unlock этой блокировки. Вот на самом деле, если вот такая вещь происходит функции, то, например, там, если говорить на Java переноситься, то в Джаве это равносильно
33:00
Speaker A
поставить модификатор синхрона метод. Вот ещё в Go есть тоже такой паттерн, а, который можно использовать, чтобы более, а, было удобнее работать с блокировками.
33:11
Speaker A
Мы сегодня увидим прямо решение задачи собеседования, где вот с таким паттерном как раз-таки можно удобно написать код.
33:17
Speaker A
В чём суть? А в Go не просто так, э, есть такой интерфейс, который называется syn loging. Вот log. Вот. И что можно сделать? А можно написать такую вот функцию Vlog. Что она будет делать? Она будет принимать на вход какой-то,
33:31
Speaker A
соответственно, вот синлокер, то есть какой-то блокировку. Вот. И действия, которые нужно выполнить. И дальше что происходит? И что происходит дальше? Смотрите, мы берём блокировочку, её отпускаем в конце через defем действие. Соответственно, вот с такой функцией везлок, она на самом деле в
33:51
Speaker A
котлине такая тоже есть. То есть в котлине буквально вот есть такая штука, типа лок, и можно под локом что-то делать. Вот в можно похожую историю написать. Делаете, да, функцию, соответственно, и в этой функции уже делаете подблокировкой всё, что нам нужно. А более того, можно по
34:06
Speaker A
аналогии с каким-нибудь on values, да, вернуть значение вообще спокойно, тость дописать эту функцию и возвращать значение. То есть такая вот такой паттерн, который позволяет не писать постоянно вот так вот, а вот так оборачивать красиво в везло тоже. А
34:22
Speaker A
довольно удобно так программировать. Что ещё? Значит, э теперь следующая вещь. Часто очень, а это вот тоже оди одно из таких вот вещей, которые часто встречаются в жизни. Вот смотрите, у вас есть какой-то массив, ну, то есть слайс, да, слайс из элемент. Вот. И что
34:40
Speaker A
происходит? У вас есть какие-то гурутины, которые пишут в разную память этого слайса, в разные участки памяти этого слайса. То есть вот, допустим, эта гурутина что делает? Она пишет в, соответственно, ну, берёт делает два присваивания. Первое присваивание она делает в поле first переменной data. Вот
35:00
Speaker A
это вот второе присваивание она делает в нулевой элемент слайсов. Что происходит со второй гросиной? Она делает присваивание в второе поле и в первый элемент слайса. То есть эти все две грузины, они никак не пересекаются с точки зрения присваива, да. И что это
35:18
Speaker A
значит? Это значит, что на самом деле здесь никакой проблемы нету. То есть, а помните, в прошлый разли, что нам нужно как-то вот делать так, чтобы у нас думать о том, когда у нас многопоточный код работает на разных ядрах. Здесь нам
35:32
Speaker A
не нужно об этом думать. Почему? Потому что у нас вот эта грутина, эта грутина, они работают с разными участками памяти, да. И вот на самом деле это тоже дело является ошибкой. То есть если вы, допустим, берёте к, да, то есть оно
35:47
Speaker A
будет работать, но вот если вы будете пытаться здесь как-то вот что-то синхронизировать, это будет избыточно, да. Тут отдельный большой вопрос, на самом деле, отсылка к мемори модулу, который у нас будет. А почему рутина мейн увидит, соответственно записи вот
36:04
Speaker A
этой рутины и этой грутины? Потому что мы же тут как помните, мы когда вот с вами рассуждали на самом на самой первой занятий карансе, а мы использовали специальные многопоточные инструкции, чтобы потом изменения одного ядра были видны другому ядру. А тут как бы хороший
36:19
Speaker A
вопрос получается. А если мы вот в этих рутинах с вами берём присваивание, делаем как без многопоточных инструкций, то как наша рутина main потом эти изменения увидят? То есть это такой ломающий мозг вопрос немножко. На самом деле здесь получается такая история, что
36:36
Speaker A
вот в этом коде немножко всё скрыто. Там что получается? Что вот в этой вот методе го там что делается, да? А там берётся, делается в запускается как раз-таки рутина.
36:49
Speaker A
Вот. И, соответственно, здесь дальше в конце должен быть выгадан. Он куда-то пропал. Давайте допишем, да, допишем гадан. А, ну что-то что-то чуть-чуть чуть-чуть пропал. Блин, ключевой вопрос какой? Как изменения вот эти, они станут видны как раз-таки main. И тут надо вспомнить, что
37:12
Speaker A
у нас вот этот го, он в конце делает vгодан. А выгадан под капотом - это многопоточная инструкция, которая как раз-таки вот эти все изменения она посинкает уже с всеми остальными. То есть такие тонкие моменты нужно понимать, что вот, допустим, здесь, да,
37:27
Speaker A
о'кей, не нужна синхронизация, но почему не нужна? Потому что мы используем дгруппу, у которой метод го под капотом сделает в конце vн. А вдан - это под капотом что такое? Это многопоточная инструкция, которая как раз-таки тут есть более формальное определение мери
37:44
Speaker A
модула всей этой истории, да? synchroniz before отношения всякие. Ну вот мы говоря интуитивно, что всё, что вот как раз-таки вот все изменения вот эти вот, они посинкаются с другими ядрами, поскольку в здесь вот используются потом многопоточные инструкции и отголоски
37:59
Speaker A
барьеров здесь тоже есть можно, но вот идейно именно так. Вот ключевой вопрос. То есть зачем нужен этот пример? Он нужен, чтобы осознать, что не всегда нужно использовать кс, чтобы как раз-таки обеспечивать критическую секцию. Если у нас те же рутины работают
38:18
Speaker A
с разными вообще участками памяти. То есть нам не нужно в этом случае никак а синхронизироваться абсолютно. То есть и естьн понятно, что если бы, допустим, брали бы и писали бы память, которая пересекается, тогда нужно было, а здесь не пересекается. Если просто будет go
38:36
Speaker A
безгруп, работать не будет. Да, да, всё верно. Если мы просто сделаем вот так, так, если мы просто сделаем вот так, а то, да, гарантии, что работать, но будет нету. То есть вот проблема в том именно, да, что а по завершению вот рутина по
38:52
Speaker A
завершению она там там есть очень тонкие гарантии, прямо очень тонкие, которые мы обсудим с моремоводум. Я опять же про это скину материалы. Не, ну доклад есть про эту историю, но да, вот конкретно здесь гарантии нету, потому что гарантина завершается и всё, типа вот
39:07
Speaker A
эти эти вот, допустим, изменения могли бы веть в кше, да? И как ты гарантируешь, что, допустим, там понятно то, что мы обсуждали, разные есть причины, а как ты обеспечишь, что они посинкаются? Что если для нас слайса ноль изначально? Еслина слайса ноль
39:25
Speaker A
изначально, мм, здесь тогда будет проблема. А проблема почему? Потому что здесь мы что делаем? Вот эта вот история, мы просто берём и, грубо говоря, записываем в участок памяти данные. А если бы мы делали историю типа вот такую append, да, то, к сожалению,
39:41
Speaker A
оно бы не работало по истории. Почему? Потому что append - это что такое? Это вот взять, соответственно, проверить, есть ли место, и потом увеличить сайз.
39:51
Speaker A
Эта история, она под капотом делает сайз+. И здесь сайз+, видишь, здесь уже всё, здесь уже общая переменна, они уже пересекаются. Значит, всё уже как бы как к сожалению надо мьюток сделать какой-то. Вот. Да, видишь, то есть тут общая переменная есть под капотом опен
40:05
Speaker A
он в слайсе. Вот, да, помнишь, рассматривали, что в слайсе ж есть под капотом. Капотом в слайсе есть соответственно длина. Если ты берёшь, делаешь опен, то как бы и здесь сайз плюс плюс, и здесь сайз. Получается, что как бы у тебя
40:21
Speaker A
общая переменная, ты изменяешь из разных грутин и все последствия, которые мы поняла? Потому что главная грусина может завершиться до того, как завершается внутренние грусины. Тут даже дело не в завершении. Смотри, дело даже не в завершении. Если ты вот сделаешь так,
40:33
Speaker A
да, вот так сделаешь и вот так сделаешь. И здесь напишешь, напишешь, например, time сleep, там, давай минуту, минуту, дождёшься вот прямо, что точно завершаться, то у тебя нет гарантии, что вот ты здесь увидишь эти эти вот результаты. У тебя их нет
40:50
Speaker A
этих гарантий. Почему? Потому что когда грутина вот эта завершается, эти данные они могли быть, например, вот этот эта грутина могла быть на потоке, понятно, исполняться на каком-то ядре один, кор 1, да, это грутина там на кор 2, кор 1,
41:05
Speaker A
2, да. И что получается, что вот эти данные могли в кэш попасть, а и допустим, вотна main у нас исполняется на Core 3, например. Вот main, она никак эти данные не увидит абсолютно. Ну, потому что как бы всё грутина
41:19
Speaker A
завершается, всё как тут нет никакого условно вот тут вот нет никакой инструкции, которая вот возьмёт, допустим, и эти данные там из крыша сбросит. То, что мы обсуждали, заставить процесс ядра договариваться.
41:31
Speaker A
И что как бы вот почему вот эта штука работает, а это нет? Потому что здесь в конце есть VГ, а VГН под капотом использует многопоточную инструкцию, которая как раз-таки вот эти изменения, она их посинкает. Можем эти вот давай
41:41
Speaker A
представь, что эти данные мы записали в кэш, вот эти вот, да, вот эти данные. И наша груна, она будет их пытаться почитать и просто будет как читать из там из своего кэша там, да, из памяти.
41:52
Speaker A
То есть она никак не будет синкаться, да, вот ядра не будут договариваться, а чтобы не договаривались, нужно вот как мы обсуждали, использовать многовоточные.
42:00
Speaker A
То есть это такой очень тонкий пример, который ломает немножко голову. Хорошо. Это пример того, что как бы не всегда нужно синхронизировать. То есть правда ли, что мы увидим? Да, правда. Опять же, если запустим, да, увидим, что всё, всё
42:13
Speaker A
хорошо. То есть 27 10 и 28 11. Да, всё, всё успешно. Следующий пример. Что касается тоже синхронизации. Что важно понимать?
42:25
Speaker A
Когда у нас есть локальная переменная в грутине, очевидно, что её не нужно никак там покрывать мтоксом. Бывает такое, что человек видит гурутину и там сразу берёт, дективно пишет lck and log. Как бы что можно понимать, как бы это рутина
42:40
Speaker A
внутри неё у нас. Понятно. Я пока говорю максимально неформальными вещами в том плане, что есть прямо формальное определение отношений сигна, си там это как бы всё можно математически описать.
42:51
Speaker A
Вот. Ну пока говорим интуитивно, что у нас переменная, она живёт в одной грудине. Соответственно, у нас она в случае никак не связана с другими потоками. Вот. И нам не нужно абсолютно ничего в этом случае синхронизировать.
43:08
Speaker A
То есть это как бы довольно такая понятная история, что если у нас доступается переменной только одной рутины, её не нужно сихронизировать. Тут как бы встаёт вопрос: а кто гарантирует, что вот если вот эта грутина, она сначала была на ядре один, потом
43:23
Speaker A
планировщик её перекинул на ядро два, и вот где гарантия, что ядро 2 увидит вот эту переменну? На самом деле тоже очень хороший вопрос. То есть где гарантия, что у нас вот смотрите, была грутина, она работала на ядре один, потом её
43:36
Speaker A
перекинули на ядро два. Вот где гарантия, что без этого мьютекса вот это вот переменную увидят вообще 2.
43:43
Speaker A
Где гарантия? Тут на самом деле вступает в игру как раз-таки операционная система. Она гарантирует, что когда делается switch, да, то у нас все как раз-таки изменения они вот тут записаны, чтобы не потерять, да. Ну тоже не очень понятно,
43:59
Speaker A
как бы. Давай изначально вопрос хороший, надо подумать. О'кей. Что касается следующего примера, это как раз-таки паттернлок. Смотрите, в go есть обычный, а есть. Мы сегодня прямо подробно обсудим его реализацию. А как он реализован под вкратце пока что с
44:19
Speaker A
такое введение? Там есть два вида блокировок. Есть блокировка на чтение, блокировка на запись. Если говорить про семантику, то какая история? Когда делается блокировка налок вот такая, да, в чём её отличие от обычной блокировки? В чём отличие отличие от такой блокировки в том, что
44:39
Speaker A
эту блокировку могут держать сразу несколько групк. То есть там такой вариант, что можем даже на самом деле зайти почитать, что соответственно а этот это блокировка может быть её могут захватывать множество читателей или только один писатель. То есть это
44:58
Speaker A
история про то, когда у нас есть много читателей и мы понимаем, что операция чтения она понятно, можем её делать из разных рутин, ничего плохого не случится. На самом деле хороший вопрос, почему mary model на это отвечает. можно более формально определить эту историю.
45:12
Speaker A
И если всё-таки есть какая-то запись, то мы понимаем, что как бы писать более чем в один поток, это не очень хорошо. Вот блокировка на чтение позволяет сказать: "О'кей, мы сейчас только читаем, если придёт какой-то писатель, пожалуйста, там, да, будем уже запрещать читать". А
45:29
Speaker A
вот это обычная блокировка, которая у нас была с вами с обычным ксом. И есть такой паттерн, который довольно удобен в GO. Называется он. Так он пишется. Как разтаки в год для этого есть интерфейс locker. То есть что можно
45:44
Speaker A
сделать? Можно взять, написать, соответственно, такую функцию, которая принимает какой-то лок и функцию, которую нужно использовать. И вот её используем. Соответственно, и можно очень красиво делать. Мы сейчас вот задачу даже решим с вами собеседование.
45:56
Speaker A
То есть мы делаем, да, соответственно, передаём туда, а либо передаём туда к, да, то есть либо обычный log, да, либо обычный лок, а либо опять же в Евроксе есть такая фича, они прямо очень так красиво сделана, что там,
46:10
Speaker A
соответственно, есть э отдельно вот свой тип acker, и у этого типа определяется как раз-таки l. Когда мы вызываем airlocker, оно просто кастит наш как бы RV Muttex в этот тип, как бы возвращает нам то, что нужно. Вот. И,
46:25
Speaker A
соответственно, что получается? Можем либо передать в эту функцию красиво, вот, либо можем передать обычный к либо RВ, то есть блокировку начтение, да? То есть говорить и можно так очень классно писать. То есть не нужно постоянно писать вот этот MX log там, да, особенно
46:42
Speaker A
если у вас там ситуация, что у вас, например, очень много кода какого-то вот здесь, да, есть, и вам нужно потом как-то, соответственно, то есть понятно, вы, допустим, def не можете написать, у вас там несколько блоков, да, вам нужно
46:53
Speaker A
как-то вот постоянно писать там, да, если что-то там, тогда там сделаю unlock и так далее. То есть это очень красиво делается, потому что можно просто обернуть вот такой вот паттерн, который с блокировками в го можно использовать.
47:06
Speaker A
Следующий пример - это вот такой задачка сведения. Вот расскажи там в чём проблема такой вот по дизайну. В чём проблема вот так написать? В чём проблема написать структурку и внутри вшить? Та вопрос. То есть почему это не очень хорошо?
47:22
Speaker A
Да, Олег правильно пишет. Копирование мюкса. Всё верно, потому что А что получается? А, во-первых, нюанс номер один. Мы помним в там есть несколько проблем, на самом деле. А мы помним с вами, да, что по-хорошему у нас как бы
47:38
Speaker A
все примитивы из пакета S не должны копироваться. Прямо это написано в документации. Явно об этом говорят. А здесь что получается? Получается, что, во-первых, у нас как бы здесь может быть копия, да? А вторая проблема, что а давайте представим, что мы эти данные
47:56
Speaker A
отдаём куда-то наружу. То есть если вот эту вот структурку отдаём куда-то наружу, получается, что внешний какой-то код может вызвать unlock.
48:04
Speaker A
нашей структуры как-то это не очень с точки зрения дизайна. То есть, допустим, если у этой вот дата структуры есть какой-то там метод AD, да, и вот если мы так делаем, то как бы у нас получается, что вот это вот не это не приватная
48:17
Speaker A
история, и поэтому её могут использовать разные участки кода. О'кей. Вот ещё такой пример, что как бы делать просто бегтекса в структуру не очень хорошо.
48:28
Speaker A
Следующее, как раз-таки переходим плавненько к задаче собеседования. Это прямо постоянно любят давать. Вот прям аа это вот эта тема, которую мы сейчас обсудим, это прям вот множество задач с собеседований, которые дают, очень часто предполагают под собой вот эту историю с шардирования. То есть
48:45
Speaker A
смотрите, а есть понятие такое формальное гранулярности блокировки. Когда у вас блокировка имеет большую и высокую гранулярность, получается следующая вещь, что у вас, а когда эту блокировку берут, то у вас процент кода, который при этом а распроливается, он очень маленький. То есть вот в эти что
49:08
Speaker A
какая блокировка самой большой группурности. Это вот как есть такая история, что майкрософты делали винду, вроде бы там третью, и у них была проблема, что они не могли отдабагать. И они что сделали? Они просто вот сделали там global log, да, и, соответственно,
49:27
Speaker A
просто брали его везде. Вот просто представьте, да, ну, специально написал. То есть вот блокировка, у которой самая большая гранулярность - это какая блокировка?
49:40
Speaker A
Это просто глобальный лок, который берут вообще везде. Вот здесь взяли, всё прекрасно. Вот. Да, всё верно, Максим.
49:47
Speaker A
Это вот это вот блокировка с самойсамой большой грурностью, когда у вас прямо это ещё называете, можете загуглить прямо этот термин такой cor. А есть понятие мелкозернистой блокировки.
49:59
Speaker A
Мелкозернистой локировки. Вот ещё он называется fine grain law, то есть мелкий, мелкозернистая блокировка. Это когда вы не блокируете всё сразу, да? А вы пытаетесь блокировать какие-то маленькие объекты, да? Вот. И чем у вас как бы утверждается гранулярность меньше, тем у вас выше парализм. И вот
50:20
Speaker A
задачи собеседования, которые часто любят давать, они построены поверх идеи того, что давайте мы пошардируем какую-то структуру данных, и у нас уменьшится гранулярность блокировки. То есть, если раньше у нас была, например, какая-то мапа, да, то есть у нас есть
50:35
Speaker A
какая-то наша син мапа, да, и у нас раньше в этой мапе что было? У нас в этой мапе раньше был один вк, да, вот и были, собственно говоря, сами данные. А были сами данные мапа там из Давайте сделаем в э что-нибуд такое. У
50:55
Speaker A
нас была какая-нибудь такая мапа. Вот. И что нам говорят? Нам говорят: "Давайте вот как бы возьмём и теперь сделаем не один мюкс и одну мапу". То есть не вот эту грубую историю, а сделаем много мютексов и много мап. И вот будем теперь
51:10
Speaker A
брать вот ключик. От этого ключика будем брать хэш и понимать, да, в какую нам нужно сходить мапу. И понятно, мы, зная как бы мапу, понимаем, какой нужно взять.
51:22
Speaker A
Ну, понятно, при желании можно сделать какой-нибудь там type shard strк, да, его там шарде там уже эту мапу. Вот. И, соответственно, написать код вот вида такого, да, что у нас есть там мапа такая. И вот у нас маба это просто что
51:37
Speaker A
такое? Это на самом деле в каком-то смысле просто слайс шартов, да, просто просто такая история. То есть это основная такая идея, которая часто на на собеседах встречается, что давайте мы возьмём и как бы пошерзируем какой-то рудан. Там есть разные соусы на
51:58
Speaker A
собеседованиях, под которым это подают. То есть могут сказать: "А вот представь, что у тебя очень много операций чтения.
52:05
Speaker A
Здесь ещё поверх этого нужно сказать: "А, ну тогда у нас будет RV бьют, да?" То есть это сейчас мы тоже решим задачу прямо про это. Это всё наслаивается.
52:12
Speaker A
Вот. То есть как выглядит базовая реализация такой задачи? Такая идея. У нас есть, соответственно, слайс наших шардов. Это можно либо написать вот так, либо прямо вот в тупую, да, явно писать слайс блокировок, слайс map и шик. Вот.
52:30
Speaker A
То есть вот пример, как написать шардированную многопоточную мапу. Берём, инициализируем соответственно наш слайс с мапами, с мьютексами. Берём середизину. Здесь можно какой-то там условно сделать при желании initial capacity. здесь что-то написать либо либо дефолт зашить, либо забить. Это
52:49
Speaker A
просто как бы опять же на собеседных часто могут, то есть такая задачка здесь могут словить на разом, да? могут словить, что вы не знаете, как написать comparable. Могут словить, что вы не знаете, что здесь можно указать капаity.
53:02
Speaker A
Могут словить, что, допустим, вы не знаете, что здесь на самом деле можно не просто капати указать, а сделать паттерн, а чтобы передавать опции в конструктор, да, вот тоже, соответственно, здесь это тоже могут сказать, что по-хорошему бы знать.
53:14
Speaker A
Дальше могут словить, что вы там не вынесли в отдельную структуру там, да, с точки зрения дизайна, а могут спросить, какой хэш вы будете использовать и почему вы будете хэш использовать. То есть тут эту задачу можно наславить кучу всего. Там условно сказали, что нагрузка
53:26
Speaker A
будет больше читателей, чем писатели. Почему вы используете обычный, а некс, да? То есть такие вещи. Вот мы сейчас тоже пообсуждаем. Так вот, берём, инициализируем. И дальше что происходит?
53:36
Speaker A
Как выглядит, собственно говоря наш? Даша Shadow, как выглядит у нас, э, set, то есть в нашу мапу. У нас есть ключик какой-то и value, да? Ну, то есть здесь string in специально просто для обращения. Мы берём, достаём по ключу,
53:56
Speaker A
соответственно, наш шарт. Опять же, тут, на самом деле, в Go есть пакет Mapш, который как раз-таки и да, вот он как раз-таки, видите, позволяет писать такие вот а более фэнн фэнн истории. То есть он позволяет э если здесь, видите, сделано просто
54:17
Speaker A
стрим, да, то в го добавили пакет недавно. Он позволяет, видите, используя comparable, писать для comparable как разтаки типов. А, и то есть можно вот, например, это вполне нормальная задача для собеседований. Напишите на дженериках вот такой вот шартиров доба.
54:34
Speaker A
То есть вообще спокойно. Так, да, то так лучше. Почему? Потому что понятно, у нас здесь тогда в таком случае в памяти как будет лежать? У нас в памяти будет лежать meex а мапа. Mutex маap, да. И мы обращаемся к Мютексу. У
54:48
Speaker A
нас кэшируется сразу вот эта часть следующая. И мы как бы чуть быстрее обратимся. Едем дальше. Тут просто для примера, да, как как это всё реализовывать. И и какая идея? Мы берём по ключу, понимаем, какой из шардов нам нужен.
55:02
Speaker A
Как мы это понимаем? Очень просто. Это индекс вот в слайсе можно взять любой абсолютно хэш, то есть там чаще ФНВ.
55:13
Speaker A
Вот. То есть берём по ключу, получаем, соответственно, чиселку. Дальше берём её по модулю. длины как раз-таки нашего нашего размера, то есть нашего размера слайса, и получаем каком шарде лежит наша мапа.
55:30
Speaker A
Вот. А дальше, соответственно, берём лог, берём, присваиваем, делаем лок. Вот здесь, если что, такая не очень хорошая реализация. Давайте вот как бы если просто я специально приберёг сейчас для, сказать, для интереса как раз-таки вот будет. А дальше вот шарedo, да, вот
55:46
Speaker A
будет задачка прямо собеседования. Я не стал просто как бы спойлерить. Вот мы сейчас прямо решим задачу и прямо сделаем всё по хорошо и красиво. Тут пока как бы сделано так просто же для идеи, да, чтобы показать, что берём
55:58
Speaker A
шарт, да, и потом по этому шарду поднимаем уже, да, мапу, берём блокировочку и в неё пишем. То есть, что получается? Если писать просто вот так, то мы берём блокировку сразу на всю маппу. А если писать вот так, то мы как
56:11
Speaker A
бы блокируем только те ключи, которые лежат в этом шарде. как бы гранулярность ниже и парализма больше, работае. Вот.
56:18
Speaker A
То есть идея такая. И это прямо частая задачка на собеседование, где нужно вот пошардировать что-то, когда вот есть много, говорят, много-много значений и нам там нужно часто обращаться. То есть если вы видите задачку, где вам говорят, что нужно работать с мапой и Мьютексом и
56:34
Speaker A
при этом говорят, что данных много, то, скорее всего, от вас хотят шардировать. Вот то же самое с гетом, то всё ровно такая же. Вот тут сейчас будет задачка прямо вот на это, прямо с интераторами, там, с женериками, там, с оптимизациями.
56:45
Speaker A
Сейчас вот дойдём. Хорошо. И как разтаки вот это пример так называемой шардированной блокировки. Вот, как я сказал, есть понятие - это груб блокировка, когда мы берём блокировку на весь объект, да, то есть, ну, я тоже так говорю, опять же, чтобы было понятно,
57:00
Speaker A
более формально, когда у нас такая грубая блокировка, она всегда идёт сравнение. То есть, когда у нас есть разные объекты, да, то есть у нас грубая блокировка, которая берёт блокировку сразу на множество этих объектов. А вот F grenate log называют ещё
57:18
Speaker A
мелкозернистая блокировка. Это блокировка, которая обычно как раз-таки используется для того, чтобы брать блокировку не на весь объект, а на части. Вот пример. Да, у нас есть банк.
57:33
Speaker A
Пишем банк. бан у нас в банке что есть? То есть у нас есть клиент, а у него есть айдишник и сумма денег на счёте. Мы, как люди порядочные, храним в копейках, то есть в минорных единицах. И у нас у
57:47
Speaker A
каждого клиента есть блокировочка. Вот. И мы хотим написать функцию. Какую функцию? А которая что делает? Которая берёт и, соответственно, переводит деньги с одного клиента на другой клиент. То есть вот функция бантрафр, она что делает? Принимает клиента left, right, первый, второй, да, и берёт
58:09
Speaker A
блокировки. Понятно? То есть на самом деле можно было бы сделать визлоком просто, да? То есть у вас просто я не хочу спойлерить, если что.
58:16
Speaker A
Просто у вас будет домашнее задание про вот эту историю писать, и там нужно будет визлок за использовать и всё остальное. Вот что происходит дальше? Мы берём блокировочки две, берём блокировочку на первый аккаунт, на второй наш вот, да, клиента нашего, и
58:31
Speaker A
переводим деньги. Всё прекрасно. То есть при желании, что мы могли бы сделать? Могли бы сделать просто war glгло, да, здрам привет. И просто мы могли вот так вообще спокойно сделать, да, то есть оно бы оно бы работало, да,
58:47
Speaker A
но понятно, было бы медленнее, конечно, потому что у нас какие-то два клиента блокируют весь банк. Мне очень приятно.
58:54
Speaker A
Поэтому мы хотим блокировку сделать конкретно, да, под навати клиента. Кто как считает, насколько эта функция, она удовлетворяет нашим требованиям, насколько она корректно хороша считать мысли. Ну давайте плюс-минус, да, плюс хорошо. А два отдельных лока. Ну так всё ж прекрасно. Два отдельных лока. У нас
59:14
Speaker A
вот есть первый клиент, второй клиент. Первый клиент, мы хотим на него блокировку взять, потом взять на второго блокировку, а потом перевести деньги.
59:23
Speaker A
Как ещё сделать? Ну, то есть я говорю, можно сделать, конечно, глобальную, но тогда будет медленно, потому что у нас два клиента блокируют весь банк. Ну, один перевод двух клиентов блокирует весь банк. Как бы мы так не хотим. А они друг друга не
59:36
Speaker A
блокнут. Ну, а как они, да, на самом деле есть проблема. Давайте вот возьмём, запустим код, который что делает? Он берёт, запускает 5.000 карутин, и каждая карутина пытается сделать панкт-трансфер там первого, второму и наоборот второму, первому. И запускаем. И что получаем?
59:53
Speaker A
Получаем в лицо, собственно говоря, дедлок. Просто делок. Ну, то есть тут не видно, на самом деле. Давайте я вот так сделаю, чтобы его виднее немножко. Так, а видите, что интересно, да? Код-то может работать. Это тоже зависит от того,
60:08
Speaker A
сколько нам повезёт. Здесь видите нам вотде здесь нам везёт. Здесь нам везёт больше это dead.
60:18
Speaker A
В чём проблема? Проблема в том, что у нас входим мы в эту функцию. У нас давайте есть есть рутина G0. Она пытается сделать перевод от, например, аккаунт 1 на аккаунт 2. 100 копек. G1 пытается сделать от второго первым тоже 100. Что получается?
60:41
Speaker A
G0 берёт вот здесь вот блокировочку. То есть вот G0 здесь берёт блокировку на первый аккаунт, то есть log первый аккаунт. А G1 тоже заходит вот сюда и берёт блокировочку на аккаунт 2. Вот в этой точке. Дальше происходит следующая
60:57
Speaker A
вещь. G0 пытается вот здесь взять блокировку на, соответственно, второй аккаунт. Вот здесь, да, G0 пытается здесь сделать блок 2, да? А G1 пытается сделать здесь лог 1. Ну, G0 пытается сдеть блокировку на настроек, но он уже занят вот здесь, да? Он уже он уже вот
61:18
Speaker A
здесь занят. его уже заблокировали. То есть вот у нас жель пытается взять блокировку на второй аккаунт, но он уже заблокирован горусиной G1. И то же самое с G1. G1 пытается взять блокировку на первый аккаунт, но он уже заблокирован
61:32
Speaker A
G0. То есть получается такая вот взаимная блокировка. И в таком случае всё у нас, к сожалению, очень грустно.
61:38
Speaker A
Как такое исправить? Есть тоже понятие довольно известное. Оно называется иерархические блокировки. Вот что такое иерархические блокировки? Иерархическая блокировка - это когда мы, зная какой-то линейный идентификатор нашего объекта, упорядочиваем взятие блокировок с помощью этого идентификатора, чтобы не допустить такой ситуации. Как как не
62:02
Speaker A
допустить такой ситуации? Вот в этом кодет стран надо написать такой код, что если у нас айдишник левого аккаунта больше, чем правого, тогда мы будем брать блокировки всегда в порядке от меньшего к большему. мы их свапаем. Вот так. То есть, а в чём идея? Да, идея в
62:20
Speaker A
том, что как раз-таки как решить эту проблему, вот здесь, которая у нас была, да, нам нужно упорядочить взятие блокировки. То есть мы говорим: "О'кей, будем всегда брать блокировку сначала на аккаунт с меньшим айдишником, потом с большим айдишником". И всё.
62:35
Speaker A
Утверждается, что вот такой подход позволит избежать взаимной блокировки. Это называется умными словами иерархическая блокировка.
62:43
Speaker A
Берём и делаем. Сначала берём меньше дишник, потом на больше. Вот пишется вот так. То есть если left больше райта, тогда их просто, ну, можно либо свапнуть, либо можно было просто ифами написать. Тут просто удобнее вот так писать. Вот. То есть такой пример, да,
62:59
Speaker A
называется иерархическая блокировка. Как раз-таки здесь без этого у нас, а, ну вот, к сожалению, оно будет падать в взаимную блогеров. А, хорошо. И, значит, следующее, что мы с вами сегодня посмотрим, а именно MКС, на самом деле, здесь тоже такой небольшое просто для
63:18
Speaker A
понимания. А, смотрите, что важно понимать ещё в конце вот разбора. Мьютексы в разных языках программирования разны. Например, что будет, а, если вы возьмёте и напишите в go вот так, так напишите MX log.
63:36
Speaker A
что будет два раза у вас будет deadlock, да? Это вот особенность такая устройства гомы. А если вы, например, возьмёте в GO, попробуете, вот смотрите, что здесь происходит. У нас main берёт блокировку, запускает рутину F и она делает unlock,
63:56
Speaker A
то есть она, то есть рутина другая делает совер делает unlock. То есть log сделала mainтина, а unlog делает f. А, и тоже, да, в го всё будет прекрасно.
64:08
Speaker A
Видите, в голо может делать рутины, которая даже не брала не брала блогеру. А, и это всё есть понятие реинтерабельности Мютекса, называется реинтерабельность. Вот, например, кс нереинтерабель. Что такое реинтерабельность? На самом деле слово очень такое звучит умно, а всё деле
64:28
Speaker A
просто. Это значит, что не хранит своего владельца. То есть кс не хранит ротину, которая его взяла. И из этого получаются эти спецэффекты, что с одной стороны мы не мы можем блокировать в одной груне, а анлокать, то есть разблокировать другой
64:45
Speaker A
груне, потому что у нас не знает, кто его заблокировал. И, например, если мы два раза сделаем лок, то у нас будет делок, потому что к не знает, какая рутина заблокировала. То есть это трейф какие-то языки программирования, как как
64:57
Speaker A
Go, они не хотят хранить владельца, потому что там в том числе подразумевается, что у как бы уртин нет айдишника, хотя мы с вами знаем, что он есть. Мы рассматривали с вами, да, рутинки есть айдишник, видите, go ID.
65:09
Speaker A
Вот он на самом деле есть, но поскольку го позиционирует, что его как бы нету, то, ну, просто решили не делать, да, лишние наклонный расход. На самом деле в каком-нибудь джаве это вполне нормальная история. То есть в джаве, если вы
65:22
Speaker A
возьмёте log два раза в одном потоке, называется, видите, ещё вот в Джаве буквально называется ренent реантерабельный. То есть он знает под капотом, кто его взял. Поэтому, например, в Джаве можно два раза брать из одного потока. В Джаве, если один
65:37
Speaker A
поток сделает unlock блокировки, которую взял другой поток, будет ошибка, потому что там явно зашито, кто владеет, да?
65:46
Speaker A
То есть при желании в го есть там разные пакеты, где можно, в частности достать адишние рутины, да, но опять же это как бы уже обход гарантии языка, поэтому тут как бы каждый решает сам. Но вкратце, что что важно понять, блокировки бывают разные.
66:02
Speaker A
То есть в нет смысла заучивать там, да, в госли два раза взять лог. Нет, го не хранит своего владельца, да, в мютексе.
66:11
Speaker A
вго не реинтерабельный кс в отличие от jaвы, например, поэтому там, если мы сделаем два раза ок, то он не знает, кто его брал, поэтому будет deadlog, то есть взаимная блокировка. Вот это важно понимать. Хорошо. А едем дальше. А
66:24
Speaker A
переходим, собственно говоря, к инфраструктуре. Смотрите, сейчас мы обсудим, как вообще реализован Mutex в Goтовится.
66:33
Speaker A
Теперь обсудим внутреннюю реализацию. А, смотрите, значит, что важно понимать. Существует множество разных классных теоретических алгоритмов. Есть одна проблема, что на практике прямо чистейший теоретический алгоритм работает, ну вот малогде. То есть прямо есть мало ниж, где только вот прям
66:55
Speaker A
условно только теоретический алгоритм. То есть очень часто в жизни на практике работает гибридная история. То есть в чём проблема, да? Вот если мы возьмём, например, наш спинлок, к сожалению, у него огромное количество недостатков.
67:08
Speaker A
Почему? Потому что когда вот эти все потоки они начнут брать comparance swap, тут есть множество проблем. Проблема номер один, что касается честности этого мютекса, то есть в плане того, что у нас может быть какая-то грутина, которую обделили вообще. То есть может быть
67:21
Speaker A
такое, что грутина не получает КСКС уже там очень давно. И в плане честности гарантии здесь нет абсолютно никакой.
67:28
Speaker A
Дальше, что касается производительности, вы хоть представляете, что будет, если все вот эти вот горутины начнут на одну и ту же ячейку памяти с разных ещё ядер?
67:38
Speaker A
доступаться, особенно если без райгошета, там будет прямо очень больно. То есть то количество опять же я даже договариваюсь, как я рассказывал, показывал сшей там вот эта история, она прямо на большом количестве потоков проигрывает. Поэтому в разных языках программирования делают разные гибридные
67:56
Speaker A
решения. А значит, давайте обсудим, как реализован Mutкс Go. А давайте базово, перед тем, как мы это обсудим, мы возьмём и поймём вообще. То есть, смотрите, в Go есть инфраструктура, на базе которой построены почти что все примитивы из пакета Си. Почти что все. И
68:15
Speaker A
мы её как раз-таки обсуждали с вами. Это как раз-таки вот этот самый сема, помните? Сема. Вот что это такое?
68:21
Speaker A
Смотрите. Идея. Мы хотим написать очередь для ожидания гороти. То есть, смотрите, у нас есть разные примех организации. Естьгруппа, есть meex, там есть ещё. Сейчас посмотрим. У них есть общие паттерн. Все они должны иметь под капотом какую-то очередь ждущих горутин. То есть в группе
68:43
Speaker A
у нас рутины ждут, пока у нас счётчик будет ноль. В Мюдексе у насны ждут, пока у нас КС разблокируется. В синкоде у нас ждут рутины, пока вызовут сигналы или бродкаст, да? То есть очень много общего. И поэтому под это написано
68:58
Speaker A
инфраструктура. Вот я буду показывать, например, груп. Мы уже разбирали. Смотрите, вот в гругруппе, помните, там есть сема. Вот у каждого примети синхронизации в го есть эта вот сема, да? У Мюкса тоже есть сема. Сема, а это просто переменная, которую заводят вот
69:15
Speaker A
внутри. Вы когда пишете, допустим, группу, да, вы когда её вот создаёте, под капотом инициализируется вот эта переменна. У этой переменной есть адрес.
69:23
Speaker A
То есть смотрите, вы решаете проблему, вам нужно для каждого приветивой синхронизации каким-то образом научиться в рантайме создавать очередь. Вопрос номер один. Как вы будете понимать детерминированно постоянно, где эта очередь находится? Ответ простой.
69:39
Speaker A
Давайте у каждого примитива заведём переменную, у которой будет какой-то адрес. И на основании этого адреса мы будем понимать, какая очередь нам нужна.
69:47
Speaker A
Так, дальше, как мы это будем понимать? Очень просто. Заведём себе, значит, 251 шарт, да? Кстати, вот, пожалуйста, падиг, да? Я уже показывал вам, что тоже пример то, что мы обсуждали с вами сшами. И что будет происходить дальше?
69:59
Speaker A
Мы будем на базе вот этого адреса, который здесь вот есть, да, для каждого прин понимать, где находится его очередь. Как мы это будем делать? Мы будем просто брать адрес, да, и брать остаток отделения от этих шартов. То есть у нас берём адрес, дальше сдвигаем
70:13
Speaker A
его на три. Просто такой вот такой вот такая функция, которая из адреса получает шарт, где лежат не очередь, сейчас чуть сложнее там будет. Сейчас проговорим. То есть мы из адреса получаем, понятно, остаток отделения берём. То есть вот у нас, грубо говоря,
70:28
Speaker A
вот просто берём адрес, да, и дальше остаток отделения, количество шардов и дальше получаем шарт и достаём отрут.
70:36
Speaker A
Этот а и на самом деле это не очередь. Смотрите, то есть на самом деле вот эта вот история - это не очередь, это дерево. Это вот rootт - это корень дерева. Уже в нём как раз-таки мы ищем очередь для каждой конкретной там ветг
70:51
Speaker A
группы, мютуса и так далее, да? Значит, в этом идея. Вот видите, что серут calls a balance ofs with. То есть мы по адресу получаем сбалансированное дерево. И дальше в этом дереве ноды этого дерева, вершинки этого дерева являются linkдлистами. И вот понятно, мы за
71:15
Speaker A
логарифм находим, то есть для каждого причини мы за логарифм находим, соответственно, ноду в этом дереве, а дальше уже за единичку мы в этом линк-листе работаем с очередью, да? То есть вот как мы решаем задачу, что у нас, допустим, для вейгруппы есть
71:27
Speaker A
очередь рутин, которые ожидают вот vвеight, да, что обсуждали, да? Как мы решаем эту задачу? Очень просто. В этой самой, соответственно, группе у нас, помните, использовал вот эту, которая runта, значит, вот, да, SE group, который на самом деле под капотом
71:46
Speaker A
использует SEQU. И вот, пожалуйста, как разтаки он здесь и есть, да, вот се а require, да, вот он, вот, пожалуйста, да, runquire, вот он, да, и вот просто он как раз-таки что делает? Потом передаёт адрес этой самой нашего, то
72:00
Speaker A
есть каждый примитив при создании этот адрес имеет. Просто поле, да, заведено во структуре. И дальше мы на основании этого поля что делаем, да? Мы получаем как раз-таки а с вами, значит, по адресу шарт, то есть получаем дерево сбалансированное. В этом дереве мы за
72:15
Speaker A
логарифм, за логарифмом находим, соответственно, linkли list. А дальше уже в этом линк-листе мы за единичку, то есть у нас там просто, если подсмотреть, да, как раз-таки, вот там находится как раз-таки дерево, вот это вот root, вот и дальше уже, соответственно, то есть за
72:35
Speaker A
логарифм в этом дереве, находя linkнлист, мы с ним работаем за единичку. То есть давайте, какую мы решаем задачу? Мы решаем задачу, что нам нужно для каждого примитива синхронизации в го научиться хранить очередь грутин, которые ожидают каких-то действий. Вот мы это и написали. Мы по
72:52
Speaker A
адресу вот этого полишка, который мы завели вот здесь вот получаем как разтаки дерево, да? В этом дереве мы уже Понятно. То есть у вас может быть такое, что два рандомных мютикса в программе попали в одно и то же дерево. Прекрасно.
73:04
Speaker A
Ну, просто возьмём в этом дереве, у нас сбалансированное, да, в дереве сбалансированном можно побольше, меньше найти нужную вершинку и прямо на равно равно сравнить. И всё прекрасно.
73:13
Speaker A
Возьмём, сравним. Вот. Понятно. Если не нашли, добавили ноду дерева. Вот. И что важно, да, опять же, чтобы это был честный логарифм, а вот как здесь, да, чтобы не было бамбука за отен, там есть всякие ротейты. Rotation, вот rotate
73:27
Speaker A
right, rotate left. Вот кто там не знает, что такое rotation, там всякие деревья, можете посмотреть, загуглить наме там самое известное дерево. Да, очень очень понятно понятно рассказано, зачем нужно делать рош. То есть, чтобы не было такого, что у вас там дерево
73:42
Speaker A
превратилось в бамбук вот такой вот, да, и на самом деле это был там не логарифм честный, а это было там уже от история, потому что на базе этого сейчас будет все остальные приметивы строиться. Там буквально вот я буду оперировать тем,
73:54
Speaker A
что есть очередь рутин. И эта очередь рутин. Как раз-таки в ней мы и то есть там есть возможность буквально по адресу получить дерево. В этом дереве найти соответственно лин linkлист, то есть ноду, да, которая лежит linkнлист.
74:09
Speaker A
И в этом линк-листе мы уже, понятно, куротины просто ждут, как вот, ну, просто обычная очередь. Смотри, я ещё раз проговорю тогда. Смотри, по адресу получаем дерево. Что такое дерево?
74:17
Speaker A
Дерево - это так граф граф, но от этого легче не стало, наверное. Смотри, а по Давай так, сейчас, чтобы просто понимать идею, давай я вот скажу. А мы по адресу получаем linkлиist. Linklлист. Понятно, что такое это очередь. То есть мы можем
74:32
Speaker A
грутинку либо положить, либо из из очереди достать, да? То есть такой вот вот есть операция какая в магазине очередь, да? Пришёл человек в очередь стал и ушёл с очереди. Вот ровно такая же структура данных. И нам она сейчас
74:46
Speaker A
понадобится. Кстати, исходники к этому видео и другие полезные материалы ты сможешь найти в моём Telegram-канале.
74:55
Speaker A
Если тебе интересно, переходи, мы будем рады тебя видеть. Ну что, продолжаем просмотр. Как работает гошный мюкс. Давайте, пошло мясо. А, значит, я тут немножко причесал, да, просто чтобы вас не пугать. Пока. Значит, первое, что мы встречаем, это, как мы часто с вами,
75:14
Speaker A
помните, я говорил, что в Go часто любят так называемый fast Ps. Fast P, так называемый. Что такое Fast P? Fast P - это вот, как помните, у нас мы рассматривали Syn Quanted.
75:24
Speaker A
В SAS P, да, вот есть slow P, есть fast. Вот то же самое у нас первая первый if.
75:32
Speaker A
Если сейчас никто mex не взял, тогда сразу берём. То есть, если получается compпом а сдвинуть, тогда сразу берём.
75:38
Speaker A
Давайте какие есть поля? А у них есть поляйт. Вот state бывает разный. А есть, э, теперь первый стейт, который есть, да, это ноль. Просто stateт ноль, что как бы всё, он сейчас, э, никем вообще не занят абсолютно, да? То есть первый первый
75:57
Speaker A
самый стоит. Прекрасно. То есть можем сразу взять и наш менют захватить. То есть это частая фишка GO. А помните, я о не упоминал, что в го очень часто любят, когда, соответственно, у нас есть какой-то вот быстрый путь и попытаться
76:14
Speaker A
как раз-таки вот по этому быстрому пути пойти. Вот. В частности, как раз-таки, да, тут так и получается. И в синкванте такое есть, да? И помните, я показывал вам, что в который, да, вот функция, которая вот здесь вот есть, да, смот, что в го прямо
76:31
Speaker A
зашита буквально табличка вот эта вот так, чтобы быстро конверсировать. То есть это частая такая история, что как бы детали реализации они обычно пытаются как-то ускорить, то есть вам не гарантируется конкретно как, да, но, соответственно, Го в этом месте
76:45
Speaker A
старается как-то делать всё быстрее. Вот. Если не получилось, тогда идём дальше. Slow. Как работает log slow? Тут прямо очень много всяких приколов. Смотрите, а значит, сперва разберёмся с такой идеей.
77:01
Speaker A
Смотрите, у Мютекса есть базовое базовое свойство, которое очень хотелось бы иметь. Это честность. Честность бывает разная. Бывает линейная, бывает квадратичная, бывает самая сильная, самая сильная гарантия частности называется first come first serf. То есть первый пришёл, первый получил блокировку.
77:21
Speaker A
Но есть проблема. Если прямо делать максимально максимально честные, он будет медленный. Поэтому в го используют гибридный вариант. В говорят, что о'кей, а значит, даже написано, что если какая-то рутина ждёт кс больше, чем 1 мисекунду, тогда включается честный мод. Если,
77:45
Speaker A
соответственно, всё хорошо, то к работает в формате, который у нас был с вами в коспе. Вот то, что мы с вами писали сами наша, которая блокировочка наша. То есть, если он умеет понимать, да, если сейчас никакую гарутину не обделяют, всё,
78:05
Speaker A
работаем, как здесь. Кто первый победил, тот и победил. Если обделяют, тогда включается так называемый Starvation mode. Мы его тоже обсудим. Вот. И первый и который нас встречает, мы говорим, что типа если сейчас starvation mode, тогда вот этот fast его не пробую. Вот если
78:25
Speaker A
starvation мода нету, тогда, видите, используется буквально спинк. Вот это буквально if, который делает спинлок.
78:31
Speaker A
Это вот буквально то, что мы с вами делали до этого. То есть, видите, здесь пытается сделать и при этом сделать спин. Вот спин - это что такое? Это вот такая функция. Она что делает? Тут прямо я вставил на самом деле код с кошный. А
78:46
Speaker A
значит, проверить, что правда ли, что GXP больше единицы вообще. То есть такие вещи проверяют тоже всякие, короче.
78:53
Speaker A
Но если говорить про как это реализовано, то есть некоторые предикаты, что вот можно ли, правда ли, что можно вообще покрутиться немножко, потому что понятно, операция активного ожидания довольно такая дорогая, как бы она то, что дорогая, она тратит впустую
79:06
Speaker A
как бы наши ресурсы. Вот если как бы можно покрутиться всё-таки, да, true. А тогда что происходит? А тогда, соответственно, runime do spin, такая функция, она делает, собственно говоря, это спин. Вот. И как этот спин работает? Это буквально на
79:23
Speaker A
аследер вот такая функция реализована. На некоторых архитектурах там используются специальные такие вот инструкции, чтобы сказать, что типа вот мы сейчас ничего не делаем, вот как бы то есть просто покрутиться, подождать.
79:35
Speaker A
То есть это вполне нормальная история. Это ровно то, что мы делали с вами до этого. Только здесь понятно не тайм сп, а как бы просто ничего не делал. То есть просто такая реализация. Опять же это если у нас сейчас нету ставеш мода. Если
79:47
Speaker A
есть, тогда мы идём дальше. Вот опять же это такая вристика. Идём дальше. Если всё-таки, ну, не получилось покрутиться, ещё что-то, что-то странное происходит, да, не получается. Очень много всяких вот есть развилок, условно, если у нас Starvation mode, тогда мы не будем
80:03
Speaker A
пытаться агрессивно бюту захватить, да? То есть смотрите, что получается. Нам говорят, что если сейчас у нас, соответственно, а Starvationна мода его нету, нету.
80:18
Speaker A
Тогда будем пытаться сразу агрессивно захватывать. Если нет, тогда пока не будем. То есть вот это вот new, что основная идея какая? Мы сейчас будем вот эту переменную new битовая маска зашивать то состояние, которое мы хотим.
80:31
Speaker A
А дальше мы будем пытаться его поменять, если к не в starvation моде. А если в starvation моде, будем просто вставать в очередь. Вот. И что происходит дальше?
80:40
Speaker A
Мы берём, проверяем, да? Значит, правда ли, что мы сейчас можем компем поменять состояние того, которое было на новое?
80:49
Speaker A
То есть в чём идея? Мы пришли такие эти с самого начала пришли, проверили. О'кей, с кем-то закрыт, да, уже всё, блокировка взята. Идём дальше. Пошли вот сюда. Так, попытались покрутиться, да, если там у нас достаточно ресурсов, да, если там
81:04
Speaker A
предикат совпал, покрутились пару раз, всё о'кей, не получилось, идём дальше. Получилось прекрасно, да? Идём дальше.
81:12
Speaker A
Что значит? Переходим сюда, да? А пытаемся уже сделать более агрессивно. Пытаемся сделать более агрессивно. То есть понятно вот здесь для понимания, чтобы вам было понятно, что спинлок он хорош, но заметьте, это буквально спинлок только если нету голодания. Вот
81:34
Speaker A
спинок плох тем, что когда голодание, то как бы у нас без какой-то реализации на очередях всё получается очень грустно.
81:40
Speaker A
Идея в чём? Да что как бы там есть всякие ифы на то, что правда ли, что у нас пробудился уже после. Давайте это пока оставим. Пока это как бы нам не очень важно. Cornerркейс. Пока что важно. Пришли, попытались покрутиться,
81:52
Speaker A
да, вот этот код. Дальше пытаемся тогда уже взять. Как мы делаем? Мы берём, а, понятно, у нас есть состояние. Вот это вот как раз-таки, помните, мы обсуждали очень сильная идея, которую нужно запомнить. Что то же самое было и в
82:04
Speaker A
группе, что мы можем в одну переменную 8 байт вшить очень много разных состояний в биты и менять её атомарно. То же самое, что у нас есть стейт, и мы в нём мы в него вшиваем сразу много состояний.
82:18
Speaker A
Так вот, покрутились вот здесь вот не получилось, идём дальше. Пытаемся посмотреть, о'кей, там пытаемся сделать new состояние, которое мы хотим, и потом кнсопом его поменять. И дальше что происходит, да? Что если мы понимаем, о'кей, всё, типа, кс взять не
82:34
Speaker A
получилось, быстро, да, прокрутиться не получилось, мы тогда уже откатываемся на такую медленную и честную реализацию. Мы что делаем? Мы говорим: "О'кей, встаём в очередь". Вот очередь у нас какая? Вот, пожалуйста, сема. Встаём в очередь.
82:48
Speaker A
Давайте судим параметры. Вот SKФAS. Я обещал, что я о них расскажу. Вот SKFAS что делает? Эта штука буквально нужна, чтобы скипнуть просто парочку стекфреймов, потому что они не нужны.
82:59
Speaker A
Там есть прямо вот эти просто, видите, вот эта штука вызывает вот вот эта штука, она вызывает под капотом обёртку, которую мы обсуждали, да, вот эта обёртка, которая вот эта, да, и просто как бы, чтобы эти обёртки лишний раз не
83:11
Speaker A
были скидны. Вот. И дальше проверка идёт, что если сейчас наша грутинка, она как бы голодает да то как бы давайте что-то делать. Если горутинка голодает, давайте что-то делать. Давайте возьмём и, соответственно, включим Starvation mode.
83:31
Speaker A
Этот вот код нужен для того, чтобы вот если бы у нас горутинка начала голодать, то есть вот есть вот 1 миллисекунда как разтаки зашита. То есть мы начинаем голодать, когда у нас, соответственно, мы понимаем, что не получается долго
83:42
Speaker A
взять. Такая идея, да? То есть как бы что ещё важно понимать, да? Смотрите, мы как бы это сделаем уже после пробуждения. То есть смотрите, что очень важно понять. Сейчас мы вот эту строчку, когда исполнили, всё, мы заснули. То
83:53
Speaker A
есть нашу рутину после этой строчки положили в очередь. То, что мы до этого обсудили. То есть нашли там дерево, в дереве нашли эликтыс. Всё, мы здесь всё мы здесь находимся в этой вот в этой очередь. Всё, мы находимся здесь. То
84:02
Speaker A
есть мы не идём сразу вот сюда. Это это блокирующая операция. Это важно понимать. Вот теперь вопрос: а кто же нас разбудит? А разбудит нас, понятное дело, unlock. На самом деле там ещё есть фоновый воркер в go, который будет
84:15
Speaker A
рутины, но это уже отдельная история. Давайте, а значит, как он будет? Смотрите. А когда вызывает анлок, что он делает?
84:24
Speaker A
Он он смотрит, что если сейчас голодания нету, то я просто разбужу какую-то грутину. Так, то есть вот здесь, да, просто разбужу какую-то горутину. Но если Starvation mode есть, то я разбужу гарону и передам ей, видите, hand of true. И тут hand of fse, тут hand of
84:46
Speaker A
true. Что такое handof? Смотрите, handof - это такая штука. А значит, что такое? Смотрите, вот этот код, который 7релис.
84:58
Speaker A
Вот смотрите, это часто ещё любят там рассказывать про это, когда протус говорят, когда без нутрянки рассказывают, говорят, что типа гарутина отдаёт управление другой гурутине. Вот не очень понятно, как она отдаёт. Вот как она отдаёт. Смотрите, вот direct gg
85:12
Speaker A
handof. То есть мы говорим: "О'кей, мы знаем, что какая-то грутина голодает. Давайте прямо возьмём и прямо ей отдадим сейчас прямо конкретно управление. Вот, э, в частности, то есть на наших ресурсах её запустим. Вот. И как это работает? А мы берём, говорим: "О'кей".
85:30
Speaker A
То есть если сейчас можно это сделать, да, вот где-то ндов, у этой самой рутинки выставляется тикет равно один. В чём суть? Мы достали эту грутину. И, значит, вы видите, вот это DQ, то есть мы достали грутину, которая ожидает. Мы
85:40
Speaker A
её достали. Мы смотрим, если к передали в флажочек, то мы у этой грунки, у этой грузинки S, да, вот судок - это на самом деле вот эта структурка судок, она же на самом деле что это просто псевдо G, она
85:54
Speaker A
represents atg invate list, то есть это для планировщика буквально рутина и мы говорим: "Всё, это ticket один, всё, она сейчас пойдёт следующая исполняться". И вызываем goal. А go она уже как раз-таки начнёт следующую рутину исполнять. Такая идея. То есть вот какда от даёт
86:10
Speaker A
управление следующей рутине, он понимает, что если сейчас включен этот самый Starvation mode, то вызываем 7лиз, то есть вот этот поп из очереди с флажком true, а флажок Hand of True просто возьмёт у горунки выставит, которая сейчас ждёт флажочек один, и
86:25
Speaker A
планировщику скажет: "Всё, тогда её дальше исполняй". И сделает go, то есть как бы, грубо говоря, возьмёт, отдаст counter, переставит на код планировщика, планировщик увидит: "Ага, порутинке SCIT 1 и program переставит уже на код горутинки". Вот вся идея. Всё, на самом
86:39
Speaker A
деле, и в этом основная суть Ньютокса. То есть либо прокрутились быстренько вот здесь, а, либо, соответственно, взяли и вставили в очередь, да? А, понятно, что можем, что что происходит. То есть давайте, как включается mode, приходит какой-то unlock, берёт, пробуждает
86:54
Speaker A
грутину. Наша грутина взяла такая вот здесь вот пробудилась. Вот тут пробудилась она вот здесь вот пробудилась. Идёт, смотрит сюда, сколько я жду мкса. Если я жду слишком много, тогда включаем Starvation mode, да? и пытается дальше, соответственно, что-то сделать. Она пытается уже, а,
87:10
Speaker A
соответственно, этот самый Starvation mode протолкнуть, да, то есть буквально вот дальше портал. Вот, то есть, видите, вот дельта Starving и дальше через atomic edin, int, да, берёт, включает как разтаки. То есть что тут важно тоже понять, да, смотрите, важно понять, что
87:29
Speaker A
вот здесь mode его можно включить mstate, то есть он сразу включается, то есть мод включается, так скажем, а, ну, не моментально, но вы поняли идею, да, что это не comp, то есть может получиться, может не получиться, а это
87:41
Speaker A
прямо in там прямо вот без эгателя делается. Вот такой вот такая реализация Мьютекса. То есть это гибридный подход, то есть это спинк, а, плюс, соответственно, честная очередь, э, да, чтобы обеспечить как раз-таки вот эту гарантию частности. First cф. Хорошо,
87:57
Speaker A
давайте теперь обсудим, а как всё-таки работает RVM. Смотрите, то есть есть ещё отдельный, называется он RV Mutex. Вот в нём есть как раз-таки буквально вот такой же, как и обычный, только у него есть операция, как мы обсудили Airlog и
88:11
Speaker A
обычная операция. Опять же, что важно понимать? Первое, то есть тут не очень много чего можно рассказывать, на самом деле. Первое, что важно понимать, что не всегда просто использовать RVM MX хорошо. Почему? Вот, например, такой вот бенчмарк, который показывает, что у нас,
88:29
Speaker A
соответственно, если а взять и использовать просто обычный декс в такой ситуации, да, для обычного инкремента, то получается гораздо, ну вот, ну не гораздо, ну вот примерно, да, где-то полтора раза разница, да, то есть потому что мы сейчас увидим, что RVMX он имеет
88:49
Speaker A
некоторые накладные расход. Вот. То есть это важно сходу понимать. А дальше в целом давайте идея такая, что когда у вас есть операции чтения, которые преобладают над операциями записи, либо в целом чтений много, то есть вот эти в целом универсальный совет поменчмаркать
89:08
Speaker A
на ваших данных посмотреть. Это прямо вообще универсально. Чуть более как бы глубина - это если у вас операций чтения их много либо вообще больше, чем записи.
89:16
Speaker A
Тогда вот можно как он, значит, опять же про Patter мы обсудили вот этот, да? Как он устроен под капотом? Как устроен R под капотом?
89:26
Speaker A
Смотрите, капотом там используется тот же самый бьют, который мы обсудили, и плюс надстройка над ними. Как пишет пишется обычный лок. Видите, тут прям веселье. Не, давайте начнём с рлокам проще.
89:39
Speaker A
Смотрите, то есть что мы хотим сделать? Мы хотим разрешить читателям каким-то образом заходить в нашу критическую секцию, если нет писателя. То есть нам нужен какой-то вот этот вот барьер, переключатель, что сейчас есть или нет писатель. И тут это сделано очень таким
89:58
Speaker A
прикольным способом. Каким образом? Есть специальный счётчик. Это количество сейчас читателей. Есть следующий инвариант. Если этот счётчик меньше нуля, значит сейчас есть писатель. Если он больше нуля, писателя нет. Вот вопрос, как его в ноль, как как его туда-сюда перекидывать? Сейчас мы на это
90:19
Speaker A
посмотрим. То есть как выглядит код airlock. Если сейчас счётчик меньше нуля, тогда встаём в очередь ожидателей.
90:28
Speaker A
Причём, видите, отдельно две очереди есть: reader 7 и Writter 7. То есть отдельно оче очередь читателей и отдельно очередь писателей. Что происходит дальше? Что происходит дальше? Дальше мы просто, если сейчас счётчик меньше нуля, встаём в очередь читать, да? И дальше что произойдёт?
90:45
Speaker A
Когда писатель закончит, он нас пробудит, и мы просто пойдём дальше. Вот на это внимание не обращайте. Нате этот код просто разметка для сетея такая пришли. Если сейчас писатель активный есть, как мы понимаем, что если счётчик меньше нуля, тогда встаём в
90:59
Speaker A
очередь, нас пробуждают и мы идём дальше. Супер. А как выглядит при этом взятие лока у писателя? Смотрите, писатель сначала пытается взять обычную блокировку. Вот обычный просто берёт обычную блокировку. Вот он её взял. Вот он её взял. Так. А дальше что
91:20
Speaker A
происходит? Дальше он хочет как бы отрезать всем ридерам возможно, то есть он хочет вот этим ридером новым, да, сказать, что всё, счётчик меньше меньше нуля вот этим, да, меньше нуля вот этого. Как он это делает? Очень просто.
91:36
Speaker A
он берёт и к счётчику добавляет некоторую magic number константу, а именно вот такое число большое, минус вот столько, да, и потом сразу же его прибавляет. То есть, поняли идею, да? Мы такие: "О'кей, всё, вот это эта строчка, она позволяет текущему писателю выиграть
91:53
Speaker A
у всех других писателей". То есть этот мькс нужен только для писателя. И дальше что происходит? Дальше мы говорим: "Хорошо, теперь нам нужно новым читателям запретить запретить входить в секцию, чтобы не пришли в очередь то, что вот этот код,
92:07
Speaker A
который сверху, да, если у нас сейчас счётчик меньше нуля, тогда в очередь нам нужно именно сказать новым читать". Мы берём и говорим: "Хорошо, теперь счётчик приявляем к нему минус такое большое число и сразу же его потом, ну, для
92:18
Speaker A
нашей локальной переменной, то есть мы как бы меняем счётчик". То есть всё этой строчкой мы новым читателям теперь запрещаем. Но проблема, остались старые читатели, нам нужно их подождать. Как нам это сделать? Очень просто. Очень просто. Мы пишем такой код. Что значит?
92:35
Speaker A
Да, понятно. Мы хотим дождаться текущего читателя. Мы как это делаем? Если сейчас есть читатели вообще какие-то, и при этом при этом у нас вот мы берём, добавляем к этому счётчику R, то есть количество читателей, которые мы ждём, то мы будем ждать. Не улыл про сначала
92:56
Speaker A
добавить рательное число и сразу прибавить и остались старые читатели. Да, смотри, тебе нужно как-то сказать новым читателям, что им нельзя больше читать, то есть, чтобы они в очередь ставали. Для этого ты говоришь, что что эта строчка делает. Эта строчка, она
93:10
Speaker A
берёт к атомик счётчику, прибавляет минус вот такую константу. Теперь любой читатель, он когда придёт, он сразу увидит: "Ага, всё, значит, я должен ждать в очереди". Всё, это вот такой такая идея. Но ты же хочешь понимать, сколько у тебя реально читателей сейчас
93:25
Speaker A
есть. Поэтому ты обратно прибавляешь к себе локальную переменную. Вот это вот это возвращает э новое значение, и ты потом прибавляешь. То есть мы просто вот эта операция, она обратная на самом деле. То есть вот эта штука, она слопывается,
93:40
Speaker A
да? А и что получается? Получается, что у тебя по факту вот в R хранится просто количество текущих читателей. Всё, ты в хранишь просто сколько сейчас читателей, но ты сейчас уже счётчик прибавил, ты его поменял, чтобы новые читатели не
93:52
Speaker A
могли приходить. Вот. И дальше ты смотришь, если сейчас всё-таки реально они есть, эти читатели, тогда ты встаёшь в очередь уже для писателей. То есть ты пришёл брать блокировку на запись, и ты встаёшь в очередь для уже писателей.
94:10
Speaker A
Вот. И что происходит дальше? Дальше как происходит unlock. То есть, смотрите, когда, собственно говоря, делается unlock для писателя, что он делает? Он обратно прибавляет эту константу большую. То есть всё, чтобы обратно плюс- плюс, да? А, наверное, не хватит
94:27
Speaker A
знания, как работает внутри. Нет, смотри, это что делает? Он берёт и это атомарная переменная, он берёт, прибавляет эту константу число. Но эта константа, она отрицательна. Минус минусми. То есть ещё раз повторите, тебе нужно сказать, смотри, вот, да, как
94:44
Speaker A
написано. Тебе нужно сказать читателям здесь этот if, да, если сейчас счётчик 1 меньше нуля, вот что делает? Он возвращает вот возвращает значение после прибавления вот этой дельты. То есть, если приходит читатель и видит, что сейчас счётчик меньше нуля, значит,
95:02
Speaker A
какой-то писатель вот здесь вот сейчас его до этого увёл специально в отрицательное значение, используя эту специальную магическую константу. И нужно, значит, подождать, встать в очередь вот сюда. Вот такая идея. И то же самое с писателем. Он берёт, понятно,
95:20
Speaker A
этот меняет этот самый счётчик, а потом, кажется, понял, записьмарной перемены анализирует качественный гортин. Ну да.
95:27
Speaker A
Пересмотри по позапрошлого занятия. Мы там прямо подробно это обсуждали, прямо очень подробно прямо писали свои атомики, прямо буквально на самом деле.
95:33
Speaker A
Вот здесь это делали. А, хорошо. И что делает писатель? Он уже это, если есть читатели активные, стоёт тоже в своей очереди. И дальше просто они друг друга как бы из этих очередей достают. То есть, что делает unlock в писатель? Он
95:47
Speaker A
берёт и обратно счётчик уводит в плюс. Да, там есть интересная проверка, очень мемная, что типа правда ли, что читателей больше этого значения. Вот такая вот а для дебага.
95:59
Speaker A
И дальше что происходит? Нам нужно взять и пробудить всех читателей, которые ждут, пока мы допишем. Мы берём буквально в цикле ровно, как и в йт гругруппе мы это делали с вами, да? В Труппе ровно такой же код написан.
96:11
Speaker A
Давайте прямо его вам продемонстрирую этот код, да? Тут там ровно такой же код написан, что просто в цикле пробуждаем все грутины. Тут то же самое, да? Берём и в цикле вот здесь вот, где log, да, пробуждаем все грутины, которые нас
96:28
Speaker A
ждут. Всё. Как сделан log, да? То же самое. Мы смотрим, если сейчас счётчик меньше нуля, значит, есть какой-то писатель активный, значит, нужно, если что, его уведомить. Мы идём сюда и проверяем. А если мы сейчас последний вот это вот, да, последний вот Ring, да,
96:45
Speaker A
это -1, то есть вот мы делаем -1 от этого счётчика и смотрим, если мы сейчас последний читатель, тогда нам нужно пробудить нашего писателя, который сейчас ждёт вот этим кодом, да, врайтерсе. То есть вот наш писатель, он заснул вот здесь, он
97:01
Speaker A
заснул вот здесь в локе, да, вот он тут заснул, да? А мы его хотим пробудить, когда мы читать закончили. Вот в этом коде мы как раз-таки посмотрим, что если сейчас мы последний читатель, мы его пробуждаем из этой очереди, да? То есть
97:13
Speaker A
по факту это тот же мьюс, который был. Только теперь у нас нету, соответственно, у нас не просто, а у нас под капотом как бы обычный мютекс для писателей и ещё, соответственно, две очереди. Одна для читателей, другая для писателей, просто чтобы понимать, кого
97:28
Speaker A
когда пробуждать. Всё. То есть это буквально Mutкс так и сделал. То есть обычный бьютекс для писателей плюс две настроечки, две очереди для писателей, читателей, чтобы друг друга пробуждать, когда мы заканчиваем телепер. Вот вся идея вымитукса. Оставилось время.
97:44
Speaker A
Значит, я что предлагаю? Значит, у нас есть время на задачку. А, и вот эти три вещи тогда я просто как материалы скину.
97:51
Speaker A
Итак, решаем задачу собеседования. Давайте задача собеседования. Нам нужно написать да. Это daily active. Daily active users counter. У нас есть счётчик. Мы хотим посчитать количество пользователей в нашем приложении. Айдишник пользователя это у нас пока строчка. На самом деле
98:12
Speaker A
похорошему бы, конечно, уи сделать, но нормально. Вот у нас есть такие операции. Добавить пользователя айдишник, строчка и буll. Правда ли, что у нас пользователь уже был. Количество пользователей, сделать ресет и итератор по всем пользователям, то есть вернуть всех пользователей.
98:31
Speaker A
Вот. И у нас есть такая базовая реализация. Мыто пришли на собеседование, написали, ну хорошо, пишем счётчик, заводим счётчик counterle, да, там можно какие-то всякие compile чеки сделать там, да, тоже что, кстати такое, да, написать. А compile check чек, что там интерфейс
98:51
Speaker A
удовлетворяем. Точно, да, красоте. Заведём мапку, да, у нас что будет в мапке? у нас мапки будет из с айдишника нашего пользователя в пустую структуру.
99:02
Speaker A
Вот опять же здесь как бы уже мы проиграли. Если мы пишем на Go124+, то вот кто видел пост, который я скидывал про новую мапу, её, короче, сломали. То есть можно при желании было на самом деле вот так написать и было бы
99:13
Speaker A
абсолютно без разницы. Вот это пофиксят в Go127. Должны поправить уже, а в Мёрзле, насколько я помню, основную ветку. То есть есть мапа из строчки в пустую структуру. Есть, значит, mex, да, для этой мапки. И как работает функция добавить пользователя. Принимаем
99:32
Speaker A
айдишник, да, возвращаем булин, если пользователь, а, опять же он новый. Как мы пишем? Ну, мы пишем блокировочку log. Делаем unlock, потом достаём нашего, берём из мапы ок. Правда ли, что пользователь у нас был? Вот если он был, тогда вернём true. И иначе
99:49
Speaker A
положим пустую структурку по айдишнику, вернём фолs Да. Вот такая usеer функция. Как будет каут работать? Берём блокировку.
99:56
Speaker A
И берём, вызываем lен от мапы. Да, всё прекрасно. Просто количество ключей в мапе. Хорошо. Как работать будет reset?
100:06
Speaker A
Берём, вызываем clearр от мапы. Всё прекрасно, да? Берём, вызываем clearр. Как работать будет итератор? Берём блокировочку и бежим по мапе, вызываем ЛТ от ключа. Вот, пожалуйста, такая вот реализация. А кто видит, какие нюансы в таком ходе? Вот прямо задачка
100:24
Speaker A
собеседования писать, то есть по модулю того, что уит у нас, ну, строчка ут. Вот как бы кто видит проблемы в таком решении. При том, что у нас это как бы понятно счётчик, usеer, там большая нагрузка, это всё. То есть очень часто add
100:40
Speaker A
вызывается юзер прямо постоянно. Да, Аня заметила первую проблему. Мы блокируем целую мап. Нехорошо. Так, какие ещё кто проблемы видит? Ну, то есть давайте представим, что user у нас используют, когда пользователь приходит. Каут у нас часто используют менеджеры, когда
100:56
Speaker A
смотрят джеборды, там смотрят красиво там график, сколько пользователей заходит на сайт. Копируем к структуре.
101:03
Speaker A
Ну, не совсем так. То есть мы же тут возвращаем указатель на counterle. И формально мы соответствуем тому самому требованию, которое я вот сказал, что у нас не должны, соответственно, э, то есть у нас у нас не копируется. То есть
101:18
Speaker A
как бы мы обеспечили, что нет копии. путём того, что мы сделали конструктор, который возвращает вот такой вот тип, да, и как бы мы поэтому не копируем. Тут всё хрут может RUS будет. Вот, Максим, Максим, да, классно заметил, что как бы казалось
101:33
Speaker A
бы каунт - это как бы операция чтения, а это запись, как бы, если у нас много, допустим, каунтов, там какой-то менеджеры зашли в дашборд и часто каунт вызывают, да, так почему бы не сделать Мюс? Нужны мелкозернистые блокировки.
101:46
Speaker A
Всегда блокировки на счётчик плюс итератор намс. Цикл в итераторе поцедата. Да. А в чём проблема? Ну вот.
101:53
Speaker A
О'кей. Да. Как ты ещё обойдёшь? Ну тебе нужно итератор сделать, который возвращает ээ всех всех пользователей.
101:59
Speaker A
Да, Олег правильно сказал, что здесь можнок. Да, согласен. Да, вот на самом деле есть ещё оптимизация сейчас, которую мы обсудим. Её Дмитрий подсветил. Мы хотим, во-первых, пошардировать, да, стандартная история.
102:09
Speaker A
Хорошо, сделаем тогда свой сет на comparable. Напишем прямо сет по-честному. Всё, мы же там на собеседовании нужно показать, что мы знаем дженерики. А вот сделаем шард. В шарде сделаем, соответственно, уже первые, да, мы хотим не просто, а RV MX.
102:21
Speaker A
И сайт у нас будет строчек. Отлично. Дальше возьмём, заведём наш счётчик уже как слайс просто шардов. Вот. И что будем делать? Будем, соответственно, брать. И, да, что ещё важно, да, не сказал никто, я тоже, что здесь, э, не
102:34
Speaker A
указан капаacсиity, здесь не указан тоже ошибка. Вот. То есть это решение, оно такое типа слабоватое сош. Что происходит дальше? Здесь мы берём, шардируем, да, и указываем здесь капаacity тоже не забыть для каждого.
102:47
Speaker A
Дальше как работает add user? А, работаем следующим образом. Мы берём по айдишнику, получаем хэшик, получаем хэшик. А дальше, соответственно, получаем по хэшику шарт, да, просто как айдишник поподелению шардов. А, получаем шарт. Дальше по шарду, понятно, по этику шарда получаем
103:04
Speaker A
уже из нашего слайса сам шарт. Вот. Дальше что мы делаем? Дальше мы берём блокировочку, да, важно airlock и проверяем, а правда ли, что сейчас пользователь пользователь есть в нашей мапе. Это первая оптимизация, потому что, смотрите, семантика такая у задачи,
103:21
Speaker A
это Daily Active users. То есть очень часто у нас будет, скорее всего, пользователи, которые заходят сайт не на сайт несколько раз. И если мы будем постоянно для этих пользователей брать блокировку именно на запись, то у нас, ну, опять же, это всё бычмаркется,
103:35
Speaker A
конечно, это всегда можно обосновать на собеседне, да, но сам факт того, что как бы это подразумевается из условия задачи, что много будет запросов, где у нас будет сразу фолс, потому что у нас пользователи много раз на сайт заходят.
103:45
Speaker A
Поэтому берём проверяем, да, если у нас сейчас пользователь уже есть, тогда возвращаем просто false. Иначе Иначе, понятно, берём уже под честной блокировкой, проверяем ещё раз, потому что между этой этой строчкой кода уже, то есть то, что Антон написал, нам нужна мелкозернистая
104:02
Speaker A
блокировка. Мелкоязернистая блокировка предполагает то, что, к сожалению, у нас нужно думать о том, что происходит, когда мы отпускаем блокировку и берём её снова. Вот. А значит, ну да, я слишком перезернил лучше шарт, а не пользователя. Да, вот видишь, Дмитрий,
104:17
Speaker A
очень хорошо ты сказал. Очень хорошо сказал. А здесь мы пользуемся такой средней гранулярностью. То есть у нас мы берём блокировку не на каждого пользователя, а в с домашнем задании нужно будет брать на каждого пользователя. Там прямо такая будет
104:30
Speaker A
мелкая груляр, а мы берём сразу на такое множество пользователя, да? То есть на шарт. То есть давайте ещё раз. получили шарт, проверили под эрлоком, правда ли, что есть. Если есть, тогда вернули фолs дальше взяли уже блокировку на запись и
104:46
Speaker A
вот ещё раз проверили. Нужно ещё раз проверить, почему вот что если вот это не сделать, да? Вот если вот это не сделать, что будет, да, между пока мы здесь отпустили и взяли блокировку, выто уже знаете, как работает с под капотом.
104:59
Speaker A
Здесь может всё, что угодно произойти. И именно поэтому нам нужно ещё раз проверить, когда мы взяли блокировку, ещё раз проверили. И если уж точно пользователь у нас его нету, его добавили и вернули. Так, а дальше как countт можно переписать? Опять же count
105:18
Speaker A
переписываем, как было до этого, только ск. То есть, как правильно сказали, по-хорошему, конечно же, log. А reset, да, значит, на самом деле, да, то же самое. То есть тут что важно, да, тоже важно понимать, что есть clearрфункция, потому что мало кто не в курсе. Там
105:34
Speaker A
некоторые люди пишут нам собеседовании, то есть вот это не очень хорошо. Прямо новая локация, лучше вот через клип. И да, в траторе, как правильно заметили, мы теперь используем airlock, а не просто обычную блокировку, да, потому что мы читаем. Как вы считаете,
105:48
Speaker A
насколько это хорошее решение? Можно ли как-то его потюнить? Ну, по разным аспектам. То есть потюнить там с точки зрения кода, производительности, ещё чего-то. То есть давайте ещё раз условие напомню, это Daily Active users Counter.
106:00
Speaker A
У нас часто вызывается user. При этом понятно, что часто у нас пользователи, которые уже на сайт зашли, каут вызывают тоже очень часто менеджеры, которые смотрят на статистику. А вот ресет вызывают в конце дня, например, forage вызывают тоже там для дам повод. Кто как
106:15
Speaker A
считает, можно ли ещё где-то улучшить какие-то вот моменты? Можно заметить, что мы в коде вот постоянно, по крайней мере, вот здесь вот, вот здесь вот в коде постоянно делаем, да? Смотрите.
106:26
Speaker A
Давайте дела что-то там unlock. Ну то есть постоянно вот какие-то вот эти воткилоки. А что можно сделать? Можно в дюзере можно в дюзере. А что вы как это переписать?
106:40
Speaker A
Можно это переписать опять же можно было написать тут я уже написал, да, реализацию. А можно что сделать? Да можно что сделать? Можно сделать, значит, такую историю. Что сделать?
106:52
Speaker A
Сделать просто окло. Вот. Соответственно, здесь передаём сюда MX Wer функция, да, которая, соответственно, что делает. Здесь у нас булин, да, здесь булин. А, и возвращаем, соответственно, просто вот такую, ну, делать ок. На самом деле понятно, можно было бы
107:15
Speaker A
сделать здесь просто бул на момент go 126. Можно написать вот так и будет эквиiv.
107:23
Speaker A
Ну, как бы ладно, мы пишем код для разных сиго, поэтому напишем. А, о'кей, берём ок. И вот можно, допустим, вот этот код вот в такой преобразовать. То же самое можно на самом деле и сделать дальше вот здесь, да? То есть, ну, просто зависит,
107:36
Speaker A
конечно, от того, ладно, тут просто тонкий момент с ремодулом, поэтому лучше вот нет, Олег, не всегда зайнланится. Гена, да, на самом деле Гена прав. Можно вот так сделать. Оно само выведит тип. Ну, я просто для более явсти написал. Видно,
107:50
Speaker A
что для читаемости. Ну, чтобы явно было видно, что функция возвращает. Вот такая история. А на самом деле здесь не окол такое, да? Вот это первая первая часть.
108:00
Speaker A
То есть первая часть, как можно было код ещё лучше сделать, это через звезлок. Вторая тонкая история, она прямо тонкая.
108:06
Speaker A
Смотрите, а в чём идея? А утверждается, что если у нас каунт вызывают часто очень наши менеджеры, то нам бы как бы каждый раз брать вот это вот по всем шардам брать блокировку на каждый шарт, что как бы не можешь. Это дорого и
108:22
Speaker A
гораздо дешевле что сделать? Сделать просто обычный счётчик. Счётчик и его поддерживать. Это очень тонкая идея, которая тоже встречается, что как бы мы хотим какую-то статистику считать, и чтобы её постоянно пересчитывать, давайте будем налитую её просто дополнять, то есть опендить, да, и вот в
108:40
Speaker A
дюзере будем делать, соответственно, здесь плюсик, да, а в каунте просто возвращаем лод, просто лод, да, а в ресете просто делаем сторну, да? То есть такая тонкая идея, что некоторые вещи можно заменить просто как append как раз-таки вещами, да, то есть вместо
108:55
Speaker A
того, чтобы пересчитывать постоянно, как мы делали с вами вот здесь, да, парш брали, шли по всем шардам и возвращаем счётчик. Да, круто. Вот это такая тонкая идея, которая тоже позволяет, то есть это на самом деле понятно, всегда нужно
109:07
Speaker A
бенчмаркать, я повторюсь, всегда на ваших данных. То есть если вам показывает какой-то бенчмарк, что вот смотрите, стало быстрее, всегда данная нагрузка. Без этого как бы первое, что должен человек показывать, данная нагрузка. Без этого, как бы, я могу б
109:17
Speaker A
меншмарк сделать почти любой, на самом деле. Ну, понятно, очень очень много где. Вот. И, соответственно, идея вот такая, да, что можно оптимизировать. То же самое здесь, да, в ресете можно вот так везло красиво сделать склером, да, здесь в итераторе
109:32
Speaker A
тоже можно красиво везлок обернуть. Будет тоже очень не как у нас было до этого здесь, да, с вот вот эти вот вот вот.
109:42
Speaker A
А вот прямо красивая такая история. Вот. И такое вот решение по итогу оно получается задача. То есть видите, да, здесь у нас и дженерики можно применить, здесь у нас и знания про мапу, здесь у нас и, соответственно, крвтек, здесь у
109:58
Speaker A
нас и, соответственно, шардированная блокировка. Здесь у нас, соответственно, и понимание атомиков, да, то есть что дёшево, что дорого, да, здесь у нас, соответственно, илог паттерн тоже, да, применяется. Здесь у нас и итераторы, здесь у нас и интерфейсы, да, здесь у
110:13
Speaker A
нас и тонкая блокировка, то, что вот мы должны, соответственно, здесь ещё раз потом проверить, да, вот эту вот историю, да, что правда ли, что у нас нет, когда мы взяли здесь кажется, что вот, казалось бы, мы уже здесь
110:25
Speaker A
проверили, зачем ещё раз проверять? Тогда ещё раз, да, потому что могло всё поменяться. Тут очень много всего. И перекладывать жесоны, когда примут на работу. Ну, разные есть работы. Вот. Но опять же, эта задача, давайте я как бы могу это сказать, эта задача из ВК, она
110:40
Speaker A
из ВК взята. То есть там прямо такая на конкаренсе была задачка. И в том числе это прямо ту буквально оттуда, короче, задача она, я её чуть-чуть усложнил, да, но задача. То есть, видите, здесь можно написать разное решение, начиная вот от
110:56
Speaker A
такого, да, а заканчивая вот таким. Вот такая вот история. Такая вот история. Смотрите, три примитива осталось. Это синмапа. Она вышла новая.
111:07
Speaker A
Вышла новая. Я скину разбор. А синol тоже я скину разбор посмотреть. Даже разборщик мусора на самом деле был. Я показывал про Синпол. А и давайте синкон. Синкон тоже это на самом деле синкон. Давайте я скажу простыми словами. Это просто буквально вот этот
111:22
Speaker A
самый сема, да, вот операция доста достать из очереди, положить в очередь, только вынесенная в библиотеку публичную. Там просто вот есть на CF лист. Я быст быстро покажу просто, чтобы кто-то будет смотреть потом, да, чтобы сразу был пререквизит для понимания, да.
111:38
Speaker A
А в Синконде по факту вот используется добавить в лист, да, а взять из листа достать одного или из листа достать всех. Всё, да, как бы вот основная иде.
111:49
Speaker A
Спасибо большое за просмотр. Переходи в мой Telegram-канал, чтобы оставаться на связи, и пиши в комментариях, какая часть из видео тебе понравилась больше всего.
Topics: Go sync WaitGroup Mutex горутины многопоточность дедлок синхронизация код-ревью примитивы

Get More with the SozAI App

Transcribe recordings, audio files, and YouTube videos — with AI summaries and speaker detection. 30 minutes free.

Or transcribe another YouTube video here →