Расширяемая конкурентность с Send и Sync
Интересно, что почти все возможности конкурентности, которые мы обсуждали до сих пор в этой главе, были частью стандартной библиотеки, а не языка. Ваши варианты обработки конкурентности не ограничены языком или стандартной библиотекой; вы можете писать свои собственные возможности конкурентности или использовать те, что написаны другими.
Однако среди ключевых концепций конкурентности, которые встроены в язык,
а не в стандартную библиотеку, есть маркерные трейты std::marker Send и Sync.
Передача владения между потоками
Маркерный трейт Send указывает, что владение значениями типа,
реализующего Send, может быть передано между потоками. Почти каждый тип Rust
реализует Send, но есть некоторые исключения, включая Rc<T>: он
не может реализовать Send, потому что если вы клонировали значение Rc<T> и попытались
передать владение клоном другому потоку, оба потока могли бы одновременно обновлять
счётчик ссылок. По этой причине Rc<T> реализован
для использования в однопоточных ситуациях, где вы не хотите платить
за потерю производительности из-за потокобезопасности.
Следовательно, система типов и ограничения трейтов Rust гарантируют, что вы никогда
случайно не передадите значение Rc<T> между потоками небезопасно. Когда мы пытались
сделать это в листинге 16-14, мы получили ошибку the trait `Send` is not implemented for `Rc<Mutex<i32>>`. Когда мы переключились на Arc<T>, который реализует
Send, код скомпилировался.
Любой тип, полностью состоящий из типов Send, автоматически помечается как Send
также. Почти все примитивные типы являются Send, кроме сырых указателей, которые
мы обсудим в двадцатой главе.
Доступ из нескольких потоков
Маркерный трейт Sync указывает, что безопасно для типа, реализующего
Sync, иметь ссылки из нескольких потоков. Другими словами, любой тип T
реализует Sync, если &T (неизменяемая ссылка на T) реализует Send,
что означает, что ссылку можно безопасно передать другому потоку. Подобно Send,
примитивные типы все реализуют Sync, а типы, полностью состоящие из типов, которые
реализуют Sync, также реализуют Sync.
Умный указатель Rc<T> также не реализует Sync по тем же причинам,
по которым он не реализует Send. Тип RefCell<T> (о котором мы говорили
в пятнадцатой главе) и семейство связанных типов Cell<T> не реализуют
Sync. Реализация проверки заимствований, которую RefCell<T> выполняет во время выполнения,
не является потокобезопасной. Умный указатель Mutex<T> реализует Sync и может
использоваться для совместного доступа из нескольких потоков, как вы видели в разделе «Разделяемый доступ к Mutex<T>».
Ручная реализация Send и Sync небезопасна
Поскольку типы, полностью состоящие из других типов, реализующих трейты Send и
Sync, также автоматически реализуют Send и Sync, нам не нужно
реализовывать эти трейты вручную. Как маркерные трейты, они даже не имеют никаких
методов для реализации. Они просто полезны для обеспечения инвариантов, связанных с
конкурентностью.
Ручная реализация этих трейтов включает написание небезопасного кода Rust.
Мы поговорим об использовании небезопасного кода Rust в двадцатой главе; пока важная
информация состоит в том, что создание новых конкурентных типов, не состоящих из частей Send и
Sync, требует тщательного обдумывания для поддержания гарантий безопасности. «Rustonomicon» содержит больше информации об этих гарантиях и о том, как
их поддерживать.
Итог
Это не последний раз, когда вы увидите конкурентность в этой книге: следующая глава посвящена асинхронному программированию, а проект в двадцать первой главе будет использовать концепции из этой главы в более реалистичной ситуации, чем небольшие примеры, обсуждавшиеся здесь.
Как упоминалось ранее, поскольку очень малая часть того, как Rust обрабатывает конкурентность, является частью языка, многие решения для конкурентности реализованы как крейты. Они развиваются быстрее, чем стандартная библиотека, поэтому обязательно ищите в интернете актуальные, современные крейты для использования в многопоточных ситуациях.
Стандартная библиотека Rust предоставляет каналы для передачи сообщений и умные
указатели, такие как Mutex<T> и Arc<T>, которые безопасно использовать в
конкурентных контекстах. Система типов и проверка заимствований гарантируют, что
код, использующий эти решения, не приведёт к гонкам данных или недопустимым ссылкам.
Как только ваш код скомпилируется, вы можете быть уверены, что он будет спокойно
работать в нескольких потоках без трудно отслеживаемых ошибок, распространённых в
других языках. Конкурентное программирование больше не концепция, которую нужно бояться:
вперёд и делайте свои программы конкурентными, бесстрашно!