Конкурентное программирование на Rust

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

Понятие конкурентности относится к выполнению разных частей программы независимо друг от друга, что легко спутать с понятием параллелизма; параллелизм делает акцент на «одновременном выполнении».

Конкурентность часто приводит к параллелизму.

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

Треды

Поток — это часть программы, которая выполняется независимо.

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

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

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

Чтобы решить эти проблемы, многие другие языки (например, Java и C#) используют специальное программное обеспечение среды выполнения для координации ресурсов, но это, несомненно, значительно снижает эффективность выполнения программы.

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

Rust не полагается на среду выполнения, подобно C/C++.

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

Но это не значит, что при программировании можно быть беспечными; на сегодняшний день проблемы, вызванные конкурентностью, не решены полностью в открытой области, и ошибки всё ещё могут возникать. Будьте как можно осторожнее при конкурентном программировании!

В Rust новые потоки создаются с помощью функции std::thread::spawn:

Пример

use std::thread;
use std::time::Duration;

fn spawn_function() {
    for i in 0..5 {
        println!("spawned thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }
}

fn main() {
    thread::spawn(spawn_function);

    for i in 0..3 {
        println!("main thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }
}

Вывод:

main thread print 0
spawned thread print 0
main thread print 1
spawned thread print 1
main thread print 2
spawned thread print 2

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

В этой программе есть дочерний поток, который выводит 5 строк текста, а главный поток выводит 3 строки текста. Но очевидно, что когда главный поток завершается, порождённый поток также завершается, не завершив весь вывод.

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

Пример

use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        for i in 0..5 {
            println!("spawned thread print {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 0..3 {
        println!("main thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }
}

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

|参数1, 参数2, ...| -> 返回值类型 {
    // 函数体
}

Например:

Пример

fn main() {
    let inc = |num: i32| -> i32 {
        num + 1
    };
    println!("inc(5) = {}", inc(5));
}

Вывод:

inc(5) = 6

Замыкания могут опускать объявления типов и использовать механизм автоматического вывода типов Rust:

Пример

fn main() {
    let inc = |num| {
        num + 1
    };
    println!("inc(5) = {}", inc(5));
}

Результат остаётся неизменным.

метод join

Пример

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 0..5 {
            println!("spawned thread print {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 0..3 {
        println!("main thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().unwrap();
}

Вывод:

main thread print 0 
spawned thread print 0 
spawned thread print 1 
main thread print 1 
spawned thread print 2 
main thread print 2 
spawned thread print 3 
spawned thread print 4

Метод join заставляет программу остановиться только после завершения дочернего потока.

move принудительно передаёт владение

Это распространённая ситуация:

Пример

use std::thread;

fn main() {
    let s = "hello";
   
    let handle = thread::spawn(|| {
        println!("{}", s);
    });

    handle.join().unwrap();
}

Попытка использовать ресурсы текущей функции в дочернем потоке определённо неверна! Потому что механизм владения запрещает эту опасную ситуацию; это нарушило бы определённость уничтожения ресурсов, которую обеспечивает механизм владения. Мы можем использовать ключевое слово move в замыканиях, чтобы справиться с этим:

Пример

use std::thread;

fn main() {
    let s = "hello";
   
    let handle = thread::spawn(move || {
        println!("{}", s);
    });

    handle.join().unwrap();
}

Передача сообщений

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

std::sync::mpsc содержит методы для передачи сообщений:

Пример

use std::thread;
use std::sync::mpsc;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Got: {}", received);
}

Вывод:

Got: hi

Дочерний поток получил отправителя tx от главного потока, вызвал его метод send для отправки строки, а затем главный поток получил её через соответствующий получатель rx.

Другие расширения