В Rust Mutex<T> представляет собой примитив синхронизации, позволяющий безопасно организовать взаимное исключение (mutual exclusion) при доступе к общим данным в условиях многопоточности. Он обеспечивает гарантированный контроль над доступом к разделяемому ресурсу, разрешая одновременно использовать его только одному потоку, блокируя остальные, пока первый не освободит ресурс.

Основы: что такое Mutex<T>

Mutex<T> — это обёртка над типом T, которая предоставляет безопасный доступ к данным внутри него. Он блокирует доступ к ресурсу до тех пор, пока текущий поток не завершит работу с ним.

use std::sync::Mutex;
let m = Mutex::new(5);
{
let mut data = m.lock().unwrap(); // блокировка
\*data += 1;
} // \`data\` выходит из области видимости — блокировка снимается

Метод lock() возвращает значение типа Result<MutexGuard, где MutexGuard<T> — это RAII-обёртка, автоматически освобождающая мьютекс, когда выходит из области видимости.

Как работает Mutex в Rust

Под капотом Mutex в Rust реализован с использованием примитивов операционной системы (например, pthread_mutex на Unix или SRWLock на Windows). Он обеспечивает:

• блокировку потока до получения доступа к данным;

• очередь ожидания: если несколько потоков просят доступ, они выстраиваются в очередь;

• автоматическую разблокировку при выходе MutexGuard из области видимости (RAII).

Мьютексы в Rust реализованы в модуле std::sync и могут быть безопасно переданы между потоками, если содержимое мьютекса также безопасно (Send и Sync трейты).

Особенности использования

1. Паника при unwrap(): метод lock() возвращает Result, так как другой поток может паниковать, удерживая мьютекс. Обычно .unwrap() используют только если точно уверены, что паники быть не может.

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

3. Блокирующее поведение: при вызове .lock() текущий поток будет заблокирован до получения доступа к данным. Это делает Mutex неподходящим для асинхронного кода — там следует использовать tokio::sync::Mutex или futures::lock::Mutex.

Когда использовать Mutex<T>

Используйте Mutex в Rust, когда:

• Нужно изменить общее состояние между потоками, но только один поток должен иметь к нему доступ в определённый момент;

• Требуется минимализм — Mutex проще и дешевле по ресурсам, чем RwLock, если нет большого числа операций чтения;

• Доступ не частый, и ожидаемая блокировка небольшая (например, при логгировании, подсчёте статистики);

• Ресурс не Copy и не Clone, и вы не можете просто склонировать его в каждый поток (в отличие от Arc<T>).

Пример с многопоточностью

use std::sync::{Arc, Mutex};
use std::thread;
let counter = Arc::new(Mutex::new(0));
let mut handles = vec!\[\];
for _ in 0..10 {
let counter = Arc::clone(&counter);
let handle = thread::spawn(move || {
let mut num = counter.lock().unwrap();
\*num += 1;
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("Результат: {}", \*counter.lock().unwrap());

Здесь:

• Arc нужен для совместного владения Mutex между потоками;

• Mutex нужен для синхронизации доступа к счётчику;

• lock() блокирует поток, пока другой не освободит доступ.

Чем отличается от RwLock

• Mutex<T> блокирует всех, кроме одного потока.

• RwLock<T> позволяет одновременное чтение нескольким потокам, но только одну блокировку на запись.

Если большинство операций — это чтение, RwLock будет эффективнее.

Чем отличается от Cell и RefCell

• Cell<T> и RefCell<T> дают внутреннюю мутабельность, но не потокобезопасны.

• Mutex<T> — потокобезопасная альтернатива для многопоточного кода.

• RefCell<T> — полезен в однопоточном контексте, но приводит к панике во время выполнения, если нарушены правила заимствования. Mutex<T> приводит к блокировке потока.

Когда лучше не использовать Mutex<T>

• Если ваш код — асинхронный, используйте tokio::sync::Mutex или другие async-aware мьютексы.

• Если вы можете избежать совместного доступа и использовать channel или message passing, это часто предпочтительнее (Rust поощряет передачу владения, а не общий доступ).

• Если доступ к данным нужен только на чтение — RwLock может быть лучше.

• Если ресурсы всегда доступны для клонирования — может быть проще и быстрее использовать Arc<Clone>.