Программирование на Rust: от новичка до Middle+

1. Введение в Rust: настройка окружения и базовый синтаксис

Введение в Rust: настройка окружения и базовый синтаксис

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

Философия и архитектурные особенности языка

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

Rust предлагает третий путь. Он использует концепцию владения и систему заимствований, или borrow checker, которая проверяет безопасность работы с памятью еще на этапе компиляции.

> Rust компилируется непосредственно в нативный машинный код, предлагая производительность, сравнимую с C и C++. Он достигает этой скорости без ущерба для безопасности, что делает его подходящим для критически важных к производительности приложений. > > Учебник по Rust: Стартовое руководство

Если представить это в виде чисел, то программа, обрабатывающая 1 000 000 сетевых запросов в секунду на традиционном языке со сборщиком мусора, может периодически останавливаться на 50-100 миллисекунд для очистки памяти. В масштабах высоконагруженного сервиса это приводит к задержкам. Rust выполняет ту же задачу с предсказуемой задержкой менее 1 миллисекунды, так как память освобождается ровно в тот момент, когда данные больше не нужны.

Установка инструментария разработчика

Для комфортной работы потребуется установить базовый набор утилит. Официальный и самый надежный способ сделать это — использовать rustup, консольный инсталлятор и менеджер версий.

Процесс установки зависит от операционной системы:

Для систем на базе Linux и macOS необходимо открыть терминал и выполнить команду загрузки скрипта.

Для операционной системы Windows потребуется скачать исполняемый файл rustup-init.exe с официального сайта и следовать инструкциям на экране.

Дополнительно в Windows может потребоваться установка инструментов сборки C++, так как компилятор опирается на системные библиотеки.

После завершения установки в системе появятся три ключевых компонента:

* rustc — непосредственно компилятор, который переводит исходный код в машинные инструкции. * rustup — утилита для обновления языка и переключения между его версиями. * cargo — встроенный пакетный менеджер и система сборки проектов.

Для проверки успешности установки достаточно запросить версию пакетного менеджера:

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

Анатомия базового проекта

В экосистеме Rust редко вызывают компилятор напрямую. Всю рутинную работу берет на себя Cargo. Он создает структуру папок, скачивает зависимости и управляет процессом сборки.

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

Эта команда генерирует директорию first_app со следующей структурой: * Файл Cargo.toml — манифест проекта, где описываются метаданные (название, версия) и внешние библиотеки. * Папка src — директория для исходного кода. * Файл src/main.rs — главная точка входа в приложение.

Открыв файл main.rs, можно увидеть базовый шаблон:

Ключевое слово fn объявляет функцию. Функция main является стартовой точкой любой исполняемой программы. Внутри нее вызывается println! — это не обычная функция, а макрос, на что указывает восклицательный знак. Макросы в Rust генерируют дополнительный код на этапе компиляции, что делает их более гибкими инструментами для форматирования текста.

Управление состоянием: переменные и мутабельность

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

Если попытаться переназначить user_age = 26, компилятор выдаст ошибку. Такой подход защищает разработчика от случайного изменения данных в сложных системах. Однако программы должны реагировать на изменения. Чтобы разрешить модификацию значения, необходимо явно указать ключевое слово mut (от слова mutable).

Представим систему подсчета баллов в игре. Изначально у игрока 0 очков. При каждом успешном действии счет увеличивается на 10. Если переменная счета не будет отмечена как mut, компилятор физически не позволит собрать игру, предотвращая логическую ошибку еще до запуска.

Система типов данных

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

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

Выбор правильного типа данных критически важен для оптимизации памяти. Например, если необходимо хранить возраст человека, который никогда не превысит 150 лет, использование типа u64 (занимающего 8 байт) будет избыточным. Достаточно использовать u8, который занимает всего 1 байт, так как , и условие выполняется.

Функции и логическое ветвление

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

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

Для управления потоком выполнения используются условные конструкции if и else. Важной особенностью является то, что if — это выражение, а не просто инструкция. Это позволяет присваивать результат проверки напрямую переменной.

В данном примере математическое условие вычисляется в логическое значение. Так как , переменная weather_status получит строковое значение "Тепло".

Для многократного выполнения кода применяются циклы. Язык предоставляет три вида циклов: бесконечный loop, цикл с предусловием while и итератор for. На практике чаще всего используется for, так как он наиболее безопасен и исключает выход за границы коллекций.

Этот код выведет числа 1, 2 и 3. Конструкция 1..4 создает диапазон, который включает начальное значение, но исключает конечное. Если требуется включить и правую границу, используется синтаксис 1..=3.

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

2. Управление памятью: владение, заимствование и время жизни

Управление памятью: владение, заимствование и время жизни

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

Rust решает эту проблему с помощью уникальной системы владения (ownership). Эта концепция позволяет компилятору гарантировать безопасность памяти на этапе сборки программы, не добавляя накладных расходов во время ее выполнения.

Стек и куча: где живут данные

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

Стек работает по принципу «последним пришел — первым ушел». Доступ к данным в стеке осуществляется очень быстро, но все хранящиеся там значения должны иметь фиксированный и известный заранее размер. Например, скалярные типы данных, такие как i32 или bool, хранятся именно в стеке.

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

Три фундаментальных правила владения

Вся система управления памятью в Rust строится на трех простых правилах, которые компилятор проверяет неукоснительно:

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

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

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

> Для управления данными в куче в Rust применяется концепция ownership. Когда владелец выходит за пределы области видимости, в котором он определен, его значение удаляется из памяти. Для этого Rust автоматически вызывает специальную функцию drop(), которая очищает память. > > metanit.com

Рассмотрим, как эти правила работают на практике при передаче данных. Если мы работаем с простыми числами в стеке, происходит обычное копирование:

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

Когда мы присваиваем s1 переменной s2, Rust не копирует сами текстовые данные в куче, так как это было бы слишком медленно. Вместо этого он копирует только указатель из стека. Если бы обе переменные продолжали указывать на одну и ту же память, при их выходе из области видимости программа попыталась бы дважды очистить один и тот же участок кучи, что привело бы к критической ошибке.

Поэтому после строки let s2 = s1; переменная s1 считается недействительной. Этот процесс называется перемещением (move). Владение данными перешло к s2.

Заимствование: доступ без владения

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

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

Правила заимствования строго контролируются встроенным анализатором заимствований (borrow checker). Он гарантирует, что данные не будут изменены в тот момент, когда кто-то другой их читает.

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

Время жизни: защита от висячих ссылок

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

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

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

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

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

Синтаксис <'a> сообщает компилятору: «возвращаемая ссылка будет действительна ровно столько же, сколько будет действительна самая короткоживущая из переданных ссылок x или y». Это не меняет фактическое время жизни данных, но объясняет компилятору связь между аргументами и результатом.

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

3. Пользовательские типы: структуры, перечисления и сопоставление с образцом

Пользовательские типы: структуры, перечисления и сопоставление с образцом

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

В языке Rust создание собственных типов базируется на двух фундаментальных концепциях: структурах для объединения нескольких значений вместе и перечислениях для выбора одного значения из заданного множества вариантов.

Структуры: объединение данных

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

Rust предлагает три различных вида структур, каждый из которых решает свои специфические задачи.

| Вид структуры | Синтаксис объявления | Описание и применение | | :--- | :--- | :--- | | Классическая (C-подобная) | struct Name { field: Type } | Имеет именованные поля. Используется чаще всего для описания сложных объектов с множеством характеристик. | | Кортежная (tuple struct) | struct Name(Type1, Type2); | Поля не имеют имен, только типы. Полезна для создания новых типов-оберток над базовыми типами. | | Единичная (unit struct) | struct Name; | Не содержит никаких полей. Применяется в обобщенном программировании и для реализации маркеров поведения. |

Рассмотрим классическую структуру на примере моделирования пользователя в системе. Мы определяем шаблон данных, а затем создаем конкретный экземпляр — объект в памяти.

Обратите внимание, что для изменения отдельного поля вся структура должна быть объявлена как изменяемая с помощью ключевого слова mut. Rust не позволяет делать изменяемыми только отдельные поля структуры.

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

Перечисления: выбор из множества вариантов

Если структуры позволяют объединить данные по принципу «И то, И другое» (у пользователя есть И имя, И email), то перечисления (enums) работают по принципу «ИЛИ одно, ИЛИ другое». Они позволяют определить тип путем перечисления всех его возможных вариантов.

> Ключевое слово enum позволяет создавать тип данных, который представляет собой один из нескольких возможных вариантов. Любой вариант, действительный как struct, также действителен как enum. > > doc.rust-lang.ru

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

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

Допустим, клиент совершает покупку на сумму 5000 руб. Если он выбирает PaymentMethod::Cash, система просто фиксирует факт оплаты. Если выбирается PaymentMethod::CreditCard("1234-5678-9012-3456".to_string()), система получает не только статус, но и конкретный номер карты для отправки запроса в банк-эквайер. Все эти совершенно разные по структуре данные имеют один общий тип — PaymentMethod.

Сопоставление с образцом: мощь оператора match

Для работы со сложными структурами и перечислениями необходим инструмент, способный анализировать их содержимое и направлять поток выполнения программы в зависимости от того, какие данные находятся внутри. Эту задачу решает сопоставление с образцом (pattern matching) с помощью конструкции match.

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

Ключевые правила работы с match:

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

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

Порядок: шаблоны проверяются сверху вниз. Выполняется только первый совпавший вариант.

В блоке PaymentMethod::CreditCard(card_number) переменная card_number автоматически связывается со строкой, хранящейся внутри перечисления, и становится доступной для использования внутри фигурных скобок.

Рассмотрим пример с числами и математическими условиями. В match можно использовать охранные выражения (match guards) для дополнительной фильтрации. Если мы обрабатываем скидки, мы можем задать условие: если сумма покупки руб., применяется максимальная скидка, если — средняя, а если — скидка не предоставляется.

Обработка отсутствия значения: перечисление Option

Одной из самых частых причин падения программ в языках вроде Java или C# является ошибка обращения к нулевому указателю (NullPointerException). Создатель концепции Null Тони Хоар назвал ее своей «ошибкой на миллиард долларов».

Rust решает эту проблему радикально: в языке вообще нет понятия Null. Вместо этого стандартная библиотека предоставляет перечисление Option<T>, которое описывает ситуацию, когда значение может либо присутствовать, либо отсутствовать.

Синтаксис <T> означает, что Option является обобщенным типом и может хранить данные любого типа. Если функция ищет пользователя в базе данных по ID, она возвращает не самого пользователя (который может быть не найден), а Option<User>.

Чтобы получить доступ к данным внутри Option, разработчик обязан использовать match или аналогичные методы, явно обрабатывая сценарий None. Это заставляет продумывать логику поведения программы при отсутствии данных еще на этапе написания кода, полностью исключая внезапные падения в рабочей среде.

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

4. Абстракции: обобщения, типажи (Traits) и обработка ошибок

Абстракции: обобщения, типажи (Traits) и обработка ошибок

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

Обобщения: универсальный код

Обобщения (generics) позволяют писать функции и структуры, которые могут работать с любым типом данных. Вместо жесткого указания конкретного типа (например, i32 или String), разработчик использует параметр типа, который традиционно обозначается заглавной буквой T.

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

Представим систему логистики, рассчитывающую координаты доставки. Если курьер перемещается по сетке складов, его позиция может быть целым числом (склад 5, ряд 10). Если же отслеживается GPS-позиция дрона, требуются точные координаты (широта 55.75, долгота 37.61). Использование обобщенной структуры позволяет применять одни и те же алгоритмы маршрутизации для обоих случаев, экономя сотни строк кода.

Типажи: контракты поведения

Если обобщения позволяют работать с любыми типами, то типажи (traits) позволяют ограничить эти типы, требуя от них наличия определенного поведения. Типаж определяет набор методов, которые должен реализовать тип, чтобы соответствовать заданному контракту.

> Trait'ы в Rust — это один из ключевых инструментов абстракции. Они позволяют определить поведение, которое можно реализовать для различных типов. Trait'ы обеспечивают способ выразить «что умеет делать» тип, не указывая его точной природы. > > habr.com

Рассмотрим пример системы уведомлений. У нас могут быть разные каналы связи: электронная почта, SMS, push-уведомления. Все они должны уметь отправлять сообщения.

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

Если в базе данных зарегистрировано 1500 пользователей, и 800 из них предпочитают получать чеки на email, а 700 — по SMS, система может итерироваться по массиву объектов, реализующих типаж Notifier, и вызывать метод send для каждого, не вникая во внутреннее устройство конкретного канала связи.

Динамическая диспетчеризация и Trait-объекты

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

Для решения этой проблемы применяются Trait-объекты (trait objects), которые обеспечивают полиморфизм во время выполнения программы.

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

При использовании Trait-объектов программа тратит дополнительные ресурсы на поиск нужного метода в виртуальной таблице методов (vtable) в момент выполнения. Если статическая диспетчеризация выполняется за условные 0 наносекунд накладных расходов, то динамическая может занимать несколько дополнительных тактов процессора. При обработке 1 000 000 объектов в цикле это может вылиться в миллисекунды задержки. Поэтому в Rust принято по умолчанию использовать обобщения, переходя к dyn Trait только тогда, когда действительно необходима гетерогенная коллекция.

Обработка ошибок: предсказуемая надежность

В отличие от многих популярных языков, Rust отказывается от механизма исключений (exceptions) на базе блоков try/catch. Исключения часто нарушают линейный поток выполнения программы и скрывают потенциальные точки сбоя. Вместо этого Rust использует систему типов для явной обработки ошибок.

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

Вариант Ok содержит успешный результат типа T, а Err — информацию об ошибке типа E. Разработчик обязан явно обработать оба сценария.

Рассмотрим пошаговый процесс работы с потенциально опасной операцией:

Вызов функции, возвращающей Result (например, чтение файла или парсинг числа из строки).

Использование оператора match или специальных методов для проверки результата.

Извлечение данных в случае успеха или логирование/возврат ошибки в случае неудачи.

В этом примере используется оператор ?. Это синтаксический сахар, который автоматически распаковывает значение из Ok, а в случае Err немедленно прерывает выполнение текущей функции и возвращает эту ошибку вызывающему коду.

Допустим, мы пишем банковское приложение. Клиент запрашивает перевод средств. Пусть баланс счета равен , а сумма перевода . Если , функция не должна аварийно завершать программу или молча возвращать нулевое значение. Она вернет Err(InsufficientFunds). Если клиент пытается перевести 5000 руб., а на счету только 3000 руб., система безопасно перехватит Err и покажет пользователю понятное предупреждение, сохраняя стабильность сервера.

Неустранимые ошибки: макрос panic!

Не все ошибки можно или нужно обрабатывать. В Rust ошибки делятся на две категории: восстановимые (например, нет доступа к сети) и невосстановимые (например, выход за пределы массива).

Для невосстановимых ошибок используется макрос panic!. При его вызове программа немедленно останавливает выполнение, очищает память и завершается с сообщением об ошибке.

> Использование panic! оправдано, когда программа оказывается в состоянии, которое разработчик не предусмотрел, и дальнейшее выполнение может привести к повреждению данных или уязвимостям безопасности.

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

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

5. Продвинутый уровень: многопоточность, макросы и асинхронное программирование

Продвинутый уровень: многопоточность, макросы и асинхронное программирование

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

Бесстрашная многопоточность

Традиционно параллельное программирование считается сложной задачей из-за состояний гонки (data races) и взаимных блокировок (deadlocks). В Rust концепции владения и заимствования применяются не только к управлению памятью, но и к потокам выполнения. Компилятор просто не позволит передать данные между потоками небезопасным способом.

Для создания нового потока операционной системы используется функция std::thread::spawn. Чтобы передать владение переменными внутрь замыкания потока, применяется ключевое слово move.

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

Arc (Atomic Reference Counted) — атомарный счетчик ссылок, позволяющий безопасно разделять владение данными между потоками.

Mutex (Mutual Exclusion) — мьютекс, гарантирующий, что в любой момент времени только один поток может изменять данные.

RwLock (Read-Write Lock) — блокировка, разрешающая множественное чтение, но только одну эксклюзивную запись.

Представим систему обработки изображений. Имеется фотографий, каждая обрабатывается 2 секунды. В одном потоке процесс займет 2000 секунд. Если разделить массив на части и обернуть счетчик прогресса в Arc<Mutex<i32>>, можно запустить потоков. Время выполнения сократится до 200 секунд, а компилятор Rust гарантирует, что счетчик прогресса не будет поврежден одновременной записью.

Макросы: метапрограммирование

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

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

В Rust существует два основных семейства макросов:

* Декларативные макросы (macro_rules!) — позволяют писать конструкции, похожие на выражения match, которые сопоставляют синтаксические шаблоны и заменяют их заданным кодом. Известный макрос vec! реализован именно так. * Процедурные макросы — работают как функции, принимающие поток токенов (исходный код) и возвращающие новый поток токенов.

Процедурные макросы делятся на три вида: Подобные функциям* — вызываются как custom_macro!(...). Подобные атрибутам* — применяются к блокам кода, например #[route("/GET")]. Пользовательские derive* — автоматически реализуют типажи для структур, например #[derive(Debug, Serialize)].

Использование макроса #[derive(Serialize)] из библиотеки serde для структуры из 50 полей экономит разработчику около 300 строк ручного кода для преобразования объекта в JSON, перекладывая эту рутину на компилятор.

Асинхронное программирование: проблема C10K

Многопоточность отлично подходит для задач, интенсивно использующих процессор (CPU-bound). Однако для сетевых приложений, где потоки большую часть времени простаивают в ожидании ответа от базы данных или клиента (I/O-bound), потоки ОС становятся слишком тяжелыми.

Каждый поток операционной системы потребляет память под стек и требует времени процессора на переключение контекста. Это приводит к «проблеме C10K» — сложности одновременной обработки 10 000 соединений.

Асинхронный Rust решает эту проблему. Ключевое слово async превращает функцию в конечный автомат, который реализует типаж Future. Вызов такой функции не выполняет её немедленно, а возвращает объект, представляющий вычисление в будущем.

Ключевое слово .await приостанавливает выполнение текущей задачи, отдавая управление исполнителю (executor), который может запустить другую задачу.

Если веб-сервер на потоках ОС при 10 000 соединений потребует около 20 ГБ оперативной памяти (по 2 МБ на стек каждого потока), то асинхронный сервер на Rust потратит на те же 10 000 соединений всего около 20-50 МБ памяти, так как асинхронные задачи представляют собой легковесные структуры данных.

Экосистема Tokio и скрытые ловушки

В отличие от других языков, стандартная библиотека Rust не содержит встроенного асинхронного исполнителя. Она предоставляет только интерфейсы (типаж Future). Для запуска асинхронного кода требуется сторонняя среда выполнения (runtime). Де-факто стандартом в индустрии стала библиотека Tokio.

Tokio предоставляет асинхронные аналоги стандартных модулей: сетевые сокеты, таймеры, файловый ввод-вывод. Однако при работе с асинхронным кодом существует критическая ловушка — блокирующие операции.

Если внутри async fn вызвать синхронную функцию std::thread::sleep или выполнить тяжелое математическое вычисление без передачи управления, это заблокирует поток исполнителя. Другие асинхронные задачи в этом потоке не смогут выполняться, что полностью уничтожит преимущества асинхронности.

Для интеграции тяжелых синхронных задач в асинхронный код Tokio предоставляет специальный пул потоков tokio::task::spawn_blocking. Это позволяет изолировать блокирующий код от легковесных асинхронных задач, сохраняя общую отзывчивость системы.