Основы и тонкости программирования на Rust

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

Добро пожаловать в курс «Основы и тонкости программирования на Rust». Мы начинаем наше путешествие с фундамента, на котором строится всё здание этого языка. Rust — это системный язык программирования, который сочетает в себе производительность C++ с безопасностью памяти и современными инструментами разработки. Он не просто предотвращает ошибки, он меняет сам подход к написанию кода.

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

Почему Rust?

Прежде чем открыть терминал, стоит понять, зачем вообще изучать Rust. Основная идея языка заключается в гарантии безопасности памяти без использования сборщика мусора (Garbage Collector). Это достигается благодаря уникальной системе владения (ownership), которую мы разберем в следующих уроках.

Rust позволяет писать код, который:

Быстрый: сопоставим по скорости с C и C++.

Надежный: компилятор предотвращает доступ к недействительной памяти и гонки данных (data races) еще до запуска программы.

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

Настройка окружения

Для разработки на Rust нам понадобится несколько инструментов. К счастью, они устанавливаются одним пакетом.

Установка через rustup

Основной способ установки Rust — использование утилиты rustup. Это инсталлятор и менеджер версий языка.

Для Linux и macOS: Откройте терминал и введите следующую команду:

Для Windows: Перейдите на официальный сайт Rust и скачайте rustup-init.exe.

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

* rustc: компилятор, который превращает ваш код в исполняемый файл. * cargo: менеджер пакетов и система сборки. Вы будете использовать его в 99% случаев. * rustup: утилита для обновления самого Rust и управления его версиями.

!Диаграмма, показывающая роль каждого инструмента: rustup управляет версиями, cargo управляет проектом, rustc компилирует код.

Чтобы проверить, что всё установилось корректно, введите в терминале:

Если вы видите номер версии, значит, мы готовы двигаться дальше.

Ваш первый проект с Cargo

Хотя можно компилировать файлы напрямую через rustc, в реальной жизни так никто не делает. Мы будем использовать cargo. Давайте создадим новый проект.

Эта команда создает директорию hello_rust со следующей структурой:

* Cargo.toml: файл манифеста, где описываются метаданные проекта и его зависимости (аналог package.json в JS или pom.xml в Java). * src/main.rs: исходный код вашей программы.

Откройте файл src/main.rs. Вы увидите классический пример:

Давайте разберем этот код:

fn main() { ... }: объявление функции. main — это точка входа в любую программу на Rust. Код внутри фигурных скобок выполняется первым.

println!("Hello, world!"): это вызов макроса, а не функции. На это указывает восклицательный знак !. Макросы в Rust — это мощный инструмент метапрограммирования, который генерирует код во время компиляции. В данном случае он выводит текст в консоль.

;: каждая инструкция должна заканчиваться точкой с запятой.

Чтобы запустить программу, выполните:

Эта команда скомпилирует проект (если были изменения) и сразу запустит его.

Переменные и неизменяемость

Здесь начинается самое интересное. В большинстве языков переменные по умолчанию можно изменять. В Rust переменные неизменяемы (immutable) по умолчанию.

Попробуйте написать такой код:

Компилятор выдаст ошибку: cannot assign twice to immutable variable x. Это сделано намеренно, чтобы избежать ошибок, связанных с неожиданным изменением состояния программы.

Ключевое слово mut

Если вы хотите, чтобы переменную можно было менять, нужно явно сообщить об этом компилятору, используя ключевое слово mut:

Теперь код скомпилируется и выполнится успешно.

Затенение (Shadowing)

В Rust есть интересная особенность: вы можете объявить новую переменную с тем же именем, что и предыдущая. Это называется затенением.

В этом примере мы трижды используем let. Каждый раз мы создаем новую переменную x, которая «затеняет» предыдущую. В итоге программа выведет 12.

В чем отличие от mut?

Мы используем let, поэтому создаем новую переменную.

Мы можем изменить тип значения. Например:

С mut такое невозможно, так как тип переменной фиксируется при создании.

Базовые типы данных

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

Типы данных делятся на две группы: скалярные и составные.

Скалярные типы

Скалярный тип представляет собой одно значение. В Rust их четыре группы.

#### 1. Целые числа (Integers)

Числа без дробной части. Они могут быть знаковыми (i — signed) и беззнаковыми (u — unsigned).

| Размер | Знаковый | Беззнаковый | | :--- | :--- | :--- | | 8-bit | i8 | u8 | | 16-bit | i16 | u16 | | 32-bit | i32 | u32 | | 64-bit | i64 | u64 | | 128-bit | i128 | u128 | | Arch | isize | usize |

* По умолчанию Rust использует i32. * Типы isize и usize зависят от архитектуры вашего компьютера (32 или 64 бита). Они часто используются для индексации коллекций.

#### 2. Числа с плавающей точкой (Floating-Point)

Числа с дробной частью. В Rust их два: * f32: 32 бита. * f64: 64 бита (по умолчанию, так как на современных процессорах он работает почти с той же скоростью, что и f32, но дает большую точность).

#### 3. Логический тип (Boolean)

Имеет два значения: true и false. Занимает 1 байт памяти. Используется в условных операторах.

#### 4. Символьный тип (Character)

Тип char в Rust — это не просто 1 байт (как в C). Это 4 байта, представляющие скалярное значение Unicode. Это значит, что char может хранить кириллицу, иероглифы и даже эмодзи.

> Обратите внимание: символы (char) пишутся в одинарных кавычках, а строки — в двойных.

Составные типы

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

#### Кортежи (Tuples)

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

!Схема структуры кортежа, показывающая, что он хранит элементы разных типов единым блоком.

#### Массивы (Arrays)

В отличие от кортежа, каждый элемент массива должен иметь один и тот же тип. Массивы в Rust имеют фиксированную длину.

Массивы полезны, когда вы хотите разместить данные в стеке (stack), а не в куче (heap), или когда вы точно знаете количество элементов (например, названия месяцев).

Доступ к элементам массива осуществляется по индексу:

Если вы попытаетесь обратиться к индексу за пределами массива, Rust выдаст ошибку времени выполнения (panic). Это еще один пример безопасности языка.

Заключение

Мы настроили окружение, написали первую программу и разобрались с базовыми кирпичиками данных в Rust. Вы узнали, что переменные неизменяемы по умолчанию, что char — это Unicode-символ, и что массивы имеют фиксированный размер.

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

Сердце Rust: концепции владения, заимствования и время жизни ссылок

В предыдущей статье мы рассмотрели базовые типы данных и узнали, что переменные в Rust неизменяемы по умолчанию. Теперь пришло время погрузиться в тему, которая делает Rust уникальным. Это «три кита» безопасности памяти: Владение (Ownership), Заимствование (Borrowing) и Время жизни (Lifetimes).

Многие новички сталкиваются здесь с трудностями, часто называемыми «борьбой с borrow checker-ом» (проверкой заимствований). Но не пугайтесь: как только вы поймете логику этих правил, вы начнете писать код, который безопасен и эффективен по своей природе.

Стек и Куча: краткий ликбез

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

Память делится на две основные области:

Стек (Stack): Работает по принципу «последним пришел — первым ушел» (LIFO). Данные здесь должны иметь фиксированный, известный размер во время компиляции (например, i32, bool, char). Доступ к стеку очень быстрый.

Куча (Heap): Используется для данных, размер которых может меняться или неизвестен при компиляции (например, String или Vector). Вы запрашиваете место, и операционная система находит свободный участок, возвращая вам указатель (адрес). Работа с кучей медленнее, так как нужно переходить по указателю.

!Стек упорядочен и быстр, куча хаотична и требует указателей.

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

Владение (Ownership)

Система владения — это набор правил, которые компилятор проверяет во время сборки. Если правила нарушены, программа просто не скомпилируется.

Три закона владения

У каждого значения в Rust есть переменная, которая называется его владельцем (owner).

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

Когда владелец выходит из области видимости (scope), значение удаляется (дропается).

Область видимости

Область видимости — это диапазон в коде, где переменная действительна. Обычно она ограничивается фигурными скобками {}.

Тип String и перемещение (Move)

Рассмотрим тип String, который хранит данные в куче.

В языках с сборщиком мусора (Java, C#) обе переменные указывали бы на одну и ту же память. В C++ это могло бы привести к копированию данных. В Rust происходит нечто иное.

Поскольку String состоит из указателя на кучу, длины и емкости (хранящихся в стеке), при присваивании s2 = s1 копируются только эти стековые данные. Сами данные в куче («hello») не копируются.

Но помните правило №2: только один владелец. Если бы Rust оставил s1 активным, то при выходе из скобок оба переменные попытались бы освободить одну и ту же память. Это ошибка «double free».

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

!При присваивании s1 переменной s2 владение данными переходит к s2, а s1 становится невалидной.

Клонирование (Clone) и Копирование (Copy)

Если вы действительно хотите сделать глубокую копию данных кучи, используйте метод clone():

Почему же тогда код let x = 5; let y = x; работает без ошибок, и x остается валидным? Потому что целые числа имеют фиксированный размер и хранятся полностью в стеке. Для таких типов существует типаж (trait) Copy. Если тип реализует Copy, переменная не перемещается, а тривиально копируется.

Заимствование (Borrowing) и Ссылки

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

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

Изменяемые ссылки

По умолчанию ссылки, как и переменные, неизменяемы. Мы не можем изменить то, что позаимствовали. Чтобы изменить, нужна изменяемая ссылка &mut.

Правила ссылок

Это самое важное правило, предотвращающее гонки данных (data races):

В любой момент времени вы можете иметь ЛИБО одну изменяемую ссылку, ЛИБО любое количество неизменяемых ссылок.

Ссылки всегда должны быть действительными.

Вы не можете сделать так:

Это правило гарантирует, что никто не изменит данные под носом у того, кто их сейчас читает.

Время жизни (Lifetimes)

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

Время жизни — это область, в которой ссылка остается валидной. Главная цель времени жизни — предотвратить появление висячих ссылок (dangling references).

Рассмотрим ошибочный код:

Rust не скомпилирует этот код, сказав, что x живет недостаточно долго (borrowed value does not live long enough).

Аннотации времени жизни

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

Почему это ошибка? Rust не знает, какую именно ссылку мы вернем — x или y. А значит, он не знает, будет ли возвращаемая ссылка валидна. Нам нужно явно связать их, используя аннотации времени жизни. Они начинаются с апострофа, например 'a.

Что мы здесь сказали компилятору: > «Функция longest принимает два параметра, которые живут как минимум столько же, сколько некое время жизни 'a. И возвращаемое значение также будет жить как минимум столько же, сколько 'a».

На практике это означает, что возвращаемая ссылка будет валидна до тех пор, пока валидны оба переданных аргумента.

!Аннотация 'a связывает время жизни входных параметров и возвращаемого значения, гарантируя безопасность.

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

Срезы (Slices)

Говоря о ссылках, нельзя не упомянуть срезы. Срез — это ссылка на часть коллекции (например, строки или массива), а не на всю коллекцию.

Тип строкового среза записывается как &str. Именно поэтому строковые литералы имеют тип &str — это срезы, указывающие на конкретное место в бинарном файле программы.

Заключение

Мы разобрали фундамент безопасности Rust:

Владение гарантирует очистку памяти.

Заимствование позволяет использовать данные без захвата владения.

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

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

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

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

Поздравляю! Вы преодолели самый крутой подъем в изучении Rust — систему владения и заимствования. Если предыдущая статья была посвящена тому, как Rust управляет памятью, то сегодня мы поговорим о том, как вы управляете данными.

В реальных программах мы редко оперируем разрозненными переменными вроде x, y или str. Мы моделируем объекты реального мира: пользователей, HTTP-запросы, геометрические фигуры или состояния игры. Для этого Rust предлагает мощные инструменты: структуры (structs) и перечисления (enums). А чтобы эффективно работать с этими данными, мы освоим конструкцию match — швейцарский нож логики в Rust.

Структуры (Structs)

Структура — это пользовательский тип данных, который позволяет упаковать несколько связанных значений в единое целое. Если вы пришли из объектно-ориентированных языков (Java, C#, Python), структуры напомнят вам классы, но с важными отличиями: в Rust структуры хранят только данные, а поведение (методы) описывается отдельно.

Определение и создание экземпляров

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

Теперь мы можем создать экземпляр этой структуры:

Обратите внимание на синтаксис ключ: значение. Порядок полей при создании не важен.

Изменяемость структур

Здесь работает то же правило, что и для обычных переменных. Если вы хотите изменять поля структуры, весь экземпляр должен быть объявлен как mut. Rust не позволяет пометить только одно поле как изменяемое.

!Визуализация структуры User в памяти, показывающая, что мутабельность применяется ко всему объекту целиком.

Кортежные структуры

Иногда имена полей избыточны. Например, для точки в трехмерном пространстве или цвета RGB нам важен только порядок и типы.

Хотя поля безымянны, к ним можно обращаться по индексу: black.0, black.1.

Методы структур

Структуры хранят данные. Но где логика? В Rust методы определяются внутри блока impl (implementation).

Давайте создадим структуру Rectangle и добавим метод для вычисления площади.

Разбор &self

В сигнатуре fn area(&self) параметр &self — это сокращение от self: &Self.

&self: Мы заимствуем структуру неизменяемо. Мы просто хотим прочитать данные (ширину и высоту).

&mut self: Мы хотим изменить данные в экземпляре.

self: Мы забираем владение экземпляром. Это используется редко, обычно для методов, которые трансформируют данные в новый тип и уничтожают старый.

Ассоциированные функции

Вы можете определить функции внутри impl, которые не принимают self. Они часто используются как конструкторы. Самый популярный пример — String::from.

Перечисления (Enums)

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

Простой пример — IP-адреса. Сейчас используется два стандарта: v4 и v6.

Хранение данных в перечислениях

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

Это позволяет создавать очень выразительные типы данных. Например, сообщение может быть или командой выхода, или координатами, или текстом.

Option: Жизнь без Null

В Rust нет значения null. Тони Хоар, изобретатель null-ссылки, назвал её своей «ошибкой на миллиард долларов», так как она приводит к множеству падений программ.

Вместо null Rust использует стандартное перечисление Option<T>, которое включено в прелюдию (доступно везде).

* Some(T) означает, что значение есть, и оно имеет тип T. * None означает, что значения нет.

Почему это лучше null? Потому что Option<T> и T — это разные типы. Компилятор не позволит вам использовать Option<T> так, будто это валидное значение. Вы обязаны проверить, есть ли там что-то, прежде чем использовать данные.

Сопоставление с образцом (Match)

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

Исчерпывающее сопоставление

Главное правило match: вы должны обработать все возможные варианты. Если мы забудем Coin::Quarter, Rust не скомпилирует код. Это гарантирует, что вы никогда не упустите граничный случай.

Извлечение значений

match может «распаковывать» данные из вариантов перечисления.

!Схема работы pattern matching с извлечением данных из вариантов перечисления.

Шаблон _ (Placeholder)

Иногда нам не нужно обрабатывать все варианты, а только некоторые, игнорируя остальные. Для этого используется _.

Конструкция if let

match может быть громоздким, если нас интересует только один вариант. Например, мы хотим выполнить код только если Option содержит значение.

Вместо этого:

Мы можем написать короче с помощью if let:

if let — это «синтаксический сахар» для match, который обрабатывает один шаблон и игнорирует остальные. Читайте это как: «Если config_max подходит под шаблон Some(max), то выполни блок кода».

Заключение

Сегодня мы добавили в наш арсенал структуры и перечисления. Теперь вы можете создавать собственные типы данных, которые точно отражают предметную область вашей программы. Мы также узнали, как Option защищает нас от ошибок отсутствия значения, и как match заставляет обрабатывать все возможные состояния системы.

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

Абстракции и надежность: обобщения, типажи и безопасная обработка ошибок

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

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

Обработка сбоев: реальный мир несовершенен, файлы теряются, а интернет отключается. Программа должна уметь выживать в таких условиях.

В этой статье мы добавим в ваш арсенал инструменты, которые делают Rust не просто быстрым, но и невероятно гибким и надежным. Мы поговорим об обобщениях (generics), типажах (traits) и обработке ошибок.

Обобщения (Generics): код для всех типов

Представьте, что вам нужно написать функцию, которая находит наибольшее число в списке. Вы пишете функцию для i32. Затем вам нужно то же самое для f64. А потом для char. Копировать и вставлять код, меняя только типы аргументов — плохая практика. Это нарушает принцип DRY (Don't Repeat Yourself).

Rust позволяет использовать обобщения — абстрактные заместители для конкретных типов.

Синтаксис обобщений

Взглянем на определение функции. Обычно мы указываем конкретный тип:

С обобщениями мы говорим: «Эта функция принимает аргумент типа T, чем бы этот T ни был».

Угловые скобки <T> после имени функции сообщают компилятору, что T — это имя обобщенного типа. Вы можете назвать его как угодно, но в Rust принято использовать короткие имена в CamelCase, и T (от Type) — стандартный выбор по умолчанию.

Обобщения в структурах

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

В этом примере x и y должны быть одного типа T. Если вы попытаетесь создать точку Point { x: 5, y: 4.0 }, компилятор выдаст ошибку, так как ожидает, что оба поля будут одного типа.

Если нужны разные типы, мы можем использовать несколько обобщений:

Производительность и Мономорфизация

Вы можете спросить: «Не замедляет ли это программу? Ведь компьютеру нужно решать, какой тип использовать во время выполнения?»

Ответ: Нет. Rust реализует обобщения с нулевой стоимостью во время выполнения.

Это достигается благодаря процессу, называемому мономорфизацией (monomorphization). Во время компиляции Rust смотрит, с какими конкретными типами вы используете обобщенный код, и генерирует отдельные версии функций и структур для каждого конкретного типа.

[VISUALIZATION: схема процесса мономорфизации | Слева показан исходный код с обобщенной функцией fn process<T>(item: T). Стрелка ведет вправо к блоку

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

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

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

Умные указатели (Smart Pointers)

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

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

Вы уже знакомы с двумя умными указателями: String и Vec<T>. Они владеют областью памяти в куче и позволяют вам управлять ею. Но в стандартной библиотеке есть и другие специализированные инструменты.

Box<T>: Данные в куче

Самый простой умный указатель — это Box<T>. Он позволяет хранить данные в куче, оставляя в стеке только указатель на них.

Зачем это нужно?

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

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

Пример рекурсивного типа (список):

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

Rc<T>: Подсчет ссылок

Правила владения Rust гласят: у значения может быть только один владелец. Но что, если мы моделируем граф, где на один узел могут ссылаться несколько других? Или телевизор в гостиной, который смотрят несколько человек?

Для этого существует Rc<T> (Reference Counting — подсчет ссылок). Он позволяет значению иметь несколько владельцев. Значение очищается только тогда, когда счетчик ссылок падает до нуля.

Важно: Rc<T> работает только в однопоточном контексте.

RefCell<T>: Внутренняя изменяемость

Помните правило: «либо одна изменяемая ссылка, либо много неизменяемых»? RefCell<T> позволяет нарушить это правило, перенося проверку заимствования с этапа компиляции на этап выполнения.

Это называется паттерном внутренней изменяемости (interior mutability). Вы можете изменять данные внутри неизменяемой структуры.

Если вы нарушите правила заимствования с RefCell (например, создадите две borrow_mut одновременно), программа не откажется компилироваться, но упадет с ошибкой (panic) во время работы.

Бесстрашная многопоточность (Fearless Concurrency)

Многопоточность — это выполнение нескольких частей программы одновременно. В языках вроде C++ это часто приводит к сложным ошибкам: гонкам данных (data races) и взаимным блокировкам (deadlocks). Rust гарантирует безопасность памяти даже здесь.

Создание потока

Для создания нового потока используется функция thread::spawn:

Передача данных: Каналы

Один из самых безопасных способов общения между потоками — не разделять память, а обмениваться сообщениями. В Rust для этого есть каналы mpsc (Multiple Producer, Single Consumer — множество производителей, один потребитель).

Представьте реку: вы пускаете кораблик (данные) по течению, и кто-то ловит его внизу.

Разделяемое состояние: Mutex и Arc

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

Но Mutex сам по себе не может быть передан в несколько потоков, так как правила владения запрещают это. Тут нам на помощь приходит Arc<T> (Atomic Reference Counting) — это потокобезопасный аналог Rc<T>.

Связка Arc<Mutex<T>> — это золотой стандарт для разделяемого состояния в Rust.

Асинхронное программирование (Async/Await)

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

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

Future и Runtime

В Rust асинхронность построена на типаже Future. Это обещание, что значение будет получено в будущем. Ключевое отличие Rust от JavaScript или C# в том, что Future в Rust ленивы. Они ничего не делают, пока вы явно не попросите их выполниться (обычно с помощью .await).

Кроме того, в стандартной библиотеке Rust нет встроенного исполнителя (runtime) для запуска асинхронного кода. Вам нужно подключить внешнюю библиотеку, например, tokio.

Пример с Tokio

Для работы этого примера в Cargo.toml нужно добавить зависимость tokio.

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

Заключение

Мы рассмотрели продвинутые инструменты Rust:

Умные указатели (Box, Rc, RefCell) дают гибкость в управлении памятью и владении.

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

Асинхронность открывает двери к созданию высокопроизводительных сетевых сервисов.

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

Спасибо, что прошли этот курс! Удачи в ваших проектах на Rust!