От однопоточного к многопоточному серверу
Сейчас сервер обрабатывает каждый запрос по очереди, что означает, что он не обработает второе соединение, пока не завершится обработка первого соединения. Если сервер получает всё больше и больше запросов, такое последовательное выполнение становится всё менее и менее оптимальным. Если сервер получает запрос, обработка которого занимает много времени, последующие запросы должны будут ждать, пока длинный запрос не завершится, даже если новые запросы могут быть обработаны быстро. Нам нужно это исправить, но сначала мы рассмотрим проблему в действии.
Имитация медленного запроса
Мы рассмотрим, как медленно обрабатываемый запрос может повлиять на другие запросы к нашей текущей реализации сервера. Листинг 21-10 реализует обработку запроса к /sleep с имитацией медленного ответа, которая заставит сервер заснуть на пять секунд перед ответом.
use std::{
fs,
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
thread,
time::Duration,
};
// --snip--
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
fn handle_connection(mut stream: TcpStream) {
// --snip--
let buf_reader = BufReader::new(&stream);
let request_line = buf_reader.lines().next().unwrap().unwrap();
let (status_line, filename) = match &request_line[..] {
"GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
"GET /sleep HTTP/1.1" => {
thread::sleep(Duration::from_secs(5));
("HTTP/1.1 200 OK", "hello.html")
}
_ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
};
// --snip--
let contents = fs::read_to_string(filename).unwrap();
let length = contents.len();
let response =
format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
stream.write_all(response.as_bytes()).unwrap();
}
Мы переключились с if на match, поскольку теперь у нас три случая. Нам нужно
явно сопоставлять со срезом request_line, чтобы сопоставлять с
строковыми литеральными значениями; match не выполняет автоматическое заимствование и
разыменование, как это делает метод равенства.
Первая ветвь такая же, как блок if из листинга 21-9. Вторая ветвь
соответствует запросу к /sleep. Когда этот запрос получен, сервер будет
спать пять секунд перед отображением успешной HTML-страницы. Третья ветвь
такая же, как блок else из листинга 21-9.
Видно, насколько примитивен наш сервер: настоящие библиотеки обрабатывали бы распознавание нескольких запросов гораздо менее многословным способом!
Запустите сервер с помощью cargo run. Затем откройте два окна браузера: одно для
http://127.0.0.1:7878, а другое для http://127.0.0.1:7878/sleep. Если
ввести URI / несколько раз, как и раньше, он ответит быстро. Но если
ввести /sleep, а затем загрузить /, вы увидите, что / ждёт, пока sleep
проспит все свои пять секунд перед загрузкой.
Есть несколько методов, которые мы могли бы использовать, чтобы избежать накопления запросов за медленным запросом, включая использование async, как мы делали в главе 17; тот, который мы реализуем, — это пул потоков.
Повышение пропускной способности с помощью пула потоков
Пул потоков — это группа порождённых потоков, которые готовы и ожидают обработки задачи. Когда программа получает новую задачу, она назначает один из потоков в пуле задаче, и этот поток обработает задачу. Оставшиеся потоки в пуле доступны для обработки любых других задач, которые поступят, пока первый поток обрабатывает. Когда первый поток завершает обработку своей задачи, он возвращается в пул простаивающих потоков, готовый обработать новую задачу. Пул потоков позволяет обрабатывать соединения одновременно, повышая пропускную способность сервера.
Мы ограничим количество потоков в пуле небольшим числом, чтобы защитить нас от DoS-атак; если бы наша программа создавала новый поток для каждого запроса по мере поступления, кто-то, сделавший 10 миллионов запросов к нашему серверу, мог бы нанести ущерб, израсходовав все ресурсы сервера и остановив обработку запросов до полной остановки.
Вместо порождения неограниченного числа потоков мы будем иметь фиксированное количество
потоков, ожидающих в пуле. Поступающие запросы отправляются в пул на
обработку. Пул будет поддерживать очередь входящих запросов. Каждый из
потоков в пуле извлекает запрос из этой очереди, обрабатывает запрос,
а затем запрашивает у очереди ещё один запрос. С такой конструкцией мы можем обрабатывать
до N запросов одновременно, где N — количество потоков. Если каждый
поток отвечает на длительный запрос, последующие запросы всё ещё могут
накапливаться в очереди, но мы увеличили количество длительных запросов,
которые можем обработать, прежде чем достигнем этой точки.
Этот приём — лишь один из многих способов повысить пропускную способность веб-сервера. Другие варианты, которые можно исследовать, — модель fork/join, однопоточная модель асинхронного ввода-вывода и многопоточная модель асинхронного ввода-вывода. Если интересна эта тема, можно почитать больше о других решениях и попробовать реализовать их; с таким низкоуровневым языком, как Rust, все эти варианты возможны.
Прежде чем начать реализацию пула потоков, давайте поговорим о том, как должно выглядеть использование пула. Когда пытаешься проектировать код, написание клиентского интерфейса первым может помочь направить проект. Напишите API кода так, чтобы он был структурирован так, как вы хотите его вызывать; затем реализуйте функциональность внутри этой структуры, а не реализуйте функциональность, а затем проектируйте публичный API.
Подобно тому, как мы использовали разработку через тестирование в проекте в главе 12, здесь мы будем использовать разработку через компилятор. Мы напишем код, который вызывает функции, которые мы хотим, а затем посмотрим на ошибки компилятора, чтобы определить, что мы должны изменить дальше, чтобы код заработал. Прежде чем это сделать, однако, мы рассмотрим приём, который мы не будем использовать в качестве отправной точки.
Порождение потока для каждого запроса
Сначала давайте рассмотрим, как мог бы выглядеть наш код, если бы он создавал новый поток для каждого соединения. Как упоминалось ранее, это не наш окончательный план из-за проблем с потенциальным порождением неограниченного числа потоков, но это отправная точка, чтобы сначала получить работающий многопоточный сервер. Затем мы добавим пул потоков в качестве улучшения, и контраст между двумя решениями будет проще.
Листинг 21-11 показывает изменения, которые нужно внести в main, чтобы порождать новый поток
для обработки каждого потока в цикле for.
use std::{
fs,
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
thread,
time::Duration,
};
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
thread::spawn(|| {
handle_connection(stream);
});
}
}
fn handle_connection(mut stream: TcpStream) {
let buf_reader = BufReader::new(&stream);
let request_line = buf_reader.lines().next().unwrap().unwrap();
let (status_line, filename) = match &request_line[..] {
"GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
"GET /sleep HTTP/1.1" => {
thread::sleep(Duration::from_secs(5));
("HTTP/1.1 200 OK", "hello.html")
}
_ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
};
let contents = fs::read_to_string(filename).unwrap();
let length = contents.len();
let response =
format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
stream.write_all(response.as_bytes()).unwrap();
}
Как вы узнали в главе 16, thread::spawn создаст новый поток и затем
запустит код в замыкании в новом потоке. Если запустить этот код и загрузить
/sleep в браузере, а затем / в двух других вкладках браузера, вы действительно увидите,
что запросы к / не должны ждать завершения /sleep. Однако, как
мы упоминали, это в конечном итоге перегрузит систему, потому что вы будете создавать
новые потоки без каких-либо ограничений.
Вы также можете вспомнить из главы 17, что это как раз та ситуация, где async и await действительно блистают! Держите это в уме, пока мы строим пул потоков, и подумайте о том, как всё выглядело бы иначе или так же с async.
Создание конечного числа потоков
Мы хотим, чтобы наш пул потоков работал похожим, привычным образом, чтобы переход
с потоков на пул потоков не требовал больших изменений в коде, использующем наш API.
Листинг 21-12 показывает гипотетический интерфейс для структуры ThreadPool,
которую мы хотим использовать вместо thread::spawn.
use std::{
fs,
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
thread,
time::Duration,
};
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
let pool = ThreadPool::new(4);
for stream in listener.incoming() {
let stream = stream.unwrap();
pool.execute(|| {
handle_connection(stream);
});
}
}
fn handle_connection(mut stream: TcpStream) {
let buf_reader = BufReader::new(&stream);
let request_line = buf_reader.lines().next().unwrap().unwrap();
let (status_line, filename) = match &request_line[..] {
"GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
"GET /sleep HTTP/1.1" => {
thread::sleep(Duration::from_secs(5));
("HTTP/1.1 200 OK", "hello.html")
}
_ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
};
let contents = fs::read_to_string(filename).unwrap();
let length = contents.len();
let response =
format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
stream.write_all(response.as_bytes()).unwrap();
}
ThreadPoolМы используем ThreadPool::new для создания нового пула потоков с настраиваемым количеством
потоков, в данном случае четырьмя. Затем в цикле for pool.execute имеет
интерфейс, похожий на thread::spawn, в том смысле, что он принимает замыкание, которое пул
должен выполнить для каждого потока. Нам нужно реализовать pool.execute так, чтобы
он принимал замыкание и передавал его потоку в пуле для выполнения. Этот код пока
не компилируется, но мы попробуем, чтобы компилятор направил нас в том, как его исправить.
Построение ThreadPool с помощью разработки через компилятор
Внесите изменения из листинга 21-12 в src/main.rs, а затем давайте используем
ошибки компилятора от cargo check для управления нашей разработкой. Вот первая
ошибка, которую мы получаем:
$ cargo check
Checking hello v0.1.0 (file:///projects/hello)
error[E0433]: cannot find type `ThreadPool` in this scope
--> src/main.rs:11:16
|
11 | let pool = ThreadPool::new(4);
| ^^^^^^^^^^ use of undeclared type `ThreadPool`
For more information about this error, try `rustc --explain E0433`.
error: could not compile `hello` (bin "hello") due to 1 previous error
Отлично! Эта ошибка сообщает нам, что нам нужен тип или модуль ThreadPool, поэтому мы
создадим его сейчас. Наша реализация ThreadPool будет независима от того, какую работу
выполняет наш веб-сервер. Поэтому давайте переключим крейт hello с
бинарного крейта на библиотечный крейт, чтобы разместить нашу реализацию ThreadPool. После
того как мы переключимся на библиотечный крейт, мы также могли бы использовать отдельную библиотеку
пула потоков для любой работы, которую мы хотим выполнять с помощью пула потоков, не только для обслуживания
веб-запросов.
Создайте файл src/lib.rs, содержащий следующее, что является простейшим
определением структуры ThreadPool, которое мы можем иметь пока:
pub struct ThreadPool;
Затем отредактируйте файл main.rs, чтобы ввести ThreadPool в область видимости из библиотечного
крейта, добавив следующий код в начало src/main.rs:
use hello::ThreadPool;
use std::{
fs,
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
thread,
time::Duration,
};
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
let pool = ThreadPool::new(4);
for stream in listener.incoming() {
let stream = stream.unwrap();
pool.execute(|| {
handle_connection(stream);
});
}
}
fn handle_connection(mut stream: TcpStream) {
let buf_reader = BufReader::new(&stream);
let request_line = buf_reader.lines().next().unwrap().unwrap();
let (status_line, filename) = match &request_line[..] {
"GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
"GET /sleep HTTP/1.1" => {
thread::sleep(Duration::from_secs(5));
("HTTP/1.1 200 OK", "hello.html")
}
_ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
};
let contents = fs::read_to_string(filename).unwrap();
let length = contents.len();
let response =
format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
stream.write_all(response.as_bytes()).unwrap();
}
Этот код всё ещё не будет работать, но давайте проверим его снова, чтобы получить следующую ошибку, которую нам нужно устранить:
$ cargo check
Checking hello v0.1.0 (file:///projects/hello)
error[E0599]: no associated function or constant named `new` found for struct `ThreadPool` in the current scope
--> src/main.rs:12:28
|
12 | let pool = ThreadPool::new(4);
| ^^^ associated function or constant not found in `ThreadPool`
For more information about this error, try `rustc --explain E0599`.
error: could not compile `hello` (bin "hello") due to 1 previous error
Эта ошибка указывает, что далее нам нужно создать связанную функцию с именем
new для ThreadPool. Мы также знаем, что new должен иметь один параметр,
который может принимать 4 в качестве аргумента, и должен возвращать экземпляр ThreadPool.
Давайте реализуем простейшую функцию new, которая будет иметь эти
характеристики:
pub struct ThreadPool;
impl ThreadPool {
pub fn new(size: usize) -> ThreadPool {
ThreadPool
}
}
Мы выбрали usize в качестве типа параметра size, потому что знаем, что
отрицательное количество потоков не имеет смысла. Мы также знаем, что будем использовать это
4 как количество элементов в коллекции потоков, для чего и предназначен тип
usize, как обсуждалось в разделе «Целочисленные типы» в главе 3.
Давайте проверим код снова:
$ cargo check
Checking hello v0.1.0 (file:///projects/hello)
error[E0599]: no method named `execute` found for struct `ThreadPool` in the current scope
--> src/main.rs:17:14
|
17 | pool.execute(|| {
| -----^^^^^^^ method not found in `ThreadPool`
For more information about this error, try `rustc --explain E0599`.
error: could not compile `hello` (bin "hello") due to 1 previous error
Теперь ошибка возникает, потому что у нас нет метода execute у ThreadPool.
Вспомните из раздела «Создание конечного числа
потоков», что мы
решили, что наш пул потоков должен иметь интерфейс, похожий на thread::spawn. Кроме
того, мы реализуем функцию execute так, чтобы она принимала замыкание,
которое ей дано, и передавала его простаивающему потоку в пуле для выполнения.
Мы определим метод execute у ThreadPool, который принимает замыкание в качестве
параметра. Вспомните из раздела «Перемещение захваченных значений из
замыканий» в главе 13, что мы можем
принимать замыкания в качестве параметров с тремя различными трейтами: Fn, FnMut и
FnOnce. Нам нужно решить, какой вид замыкания использовать здесь. Мы знаем, что в итоге
сделаем что-то похожее на реализацию thread::spawn из стандартной библиотеки, поэтому можем посмотреть, какие ограничения
имеет сигнатура thread::spawn на своём параметре. Документация показывает нам следующее:
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
F: FnOnce() -> T,
F: Send + 'static,
T: Send + 'static,
Здесь нас интересует параметр типа F; параметр типа T
связан с возвращаемым значением, и нас это не интересует. Мы
видим, что spawn использует FnOnce в качестве ограничения трейта для F. Это, вероятно,
то, что нам тоже нужно, потому что мы в конечном итоге передадим аргумент, полученный в
execute, в spawn. Мы можем быть ещё более уверены, что FnOnce — это трейт, который
нам нужен, потому что поток для выполнения запроса выполнит замыкание этого
запроса только один раз, что соответствует Once в FnOnce.
Параметр типа F также имеет ограничение трейта Send и ограничение времени жизни
'static, которые полезны в нашей ситуации: нам нужен Send для передачи
замыкания из одного потока в другой, а 'static — потому что мы не знаем, сколько времени
поток потратит на выполнение. Давайте создадим метод execute у
ThreadPool, который будет принимать обобщённый параметр типа F с этими ограничениями:
pub struct ThreadPool;
impl ThreadPool {
// --snip--
pub fn new(size: usize) -> ThreadPool {
ThreadPool
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
Мы по-прежнему используем () после FnOnce, потому что этот FnOnce представляет замыкание,
которое не принимает параметров и возвращает единичный тип (). Как и в определениях функций,
тип возвращаемого значения можно опустить из сигнатуры, но даже если у нас
нет параметров, нам всё равно нужны круглые скобки.
Опять же, это простейшая реализация метода execute: он
ничего не делает, но мы лишь пытаемся заставить наш код скомпилироваться. Давайте проверим его снова:
$ cargo check
Checking hello v0.1.0 (file:///projects/hello)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.24s
Он компилируется! Но обратите внимание, что если попробовать cargo run и сделать запрос в
браузере, вы увидите ошибки в браузере, которые мы видели в начале
главы. Наша библиотека на самом деле ещё не вызывает замыкание, переданное в execute!
Примечание: поговорка, которую можно услышать о языках со строгими компиляторами, таких как Haskell и Rust: «Если код компилируется, он работает». Но эта поговорка не универсально верна. Наш проект компилируется, но не делает абсолютно ничего! Если бы мы строили настоящий, полный проект, это было бы хорошее время начать писать модульные тесты, чтобы проверить, что код компилируется и имеет поведение, которое мы хотим.
Подумайте: что было бы иначе, если бы мы собирались выполнять фьючерс вместо замыкания?
Проверка количества потоков в new
Мы ничего не делаем с параметрами new и execute. Давайте
реализуем тела этих функций с желаемым поведением. Для начала
подумаем о new. Ранее мы выбрали беззнаковый тип для параметра size, потому что пул с
отрицательным количеством потоков не имеет смысла. Однако пул с нулём потоков тоже
не имеет смысла, а ноль — вполне допустимый usize. Мы добавим код, чтобы проверить, что
size больше нуля, прежде чем вернуть экземпляр ThreadPool, и заставим программу
паниковать, если она получит ноль, используя макрос assert!, как показано в листинге 21-13.
pub struct ThreadPool;
impl ThreadPool {
/// Создаёт новый ThreadPool.
///
/// size — количество потоков в пуле.
///
/// # Panics
///
/// Функция `new` вызовет панику, если size равен нулю.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
ThreadPool
}
// --snip--
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
ThreadPool::new для паники, если size равен нулюМы также добавили документацию для нашего ThreadPool с помощью doc-комментариев.
Обратите внимание, что мы следовали хорошим практикам документирования, добавив раздел, в котором
указываются ситуации, в которых наша функция может запаниковать, как обсуждалось в
главе 14. Попробуйте запустить cargo doc --open и щёлкнуть на структуре ThreadPool,
чтобы увидеть, как выглядит сгенерированная документация для new!
Вместо добавления макроса assert!, как мы сделали здесь, мы могли бы изменить new
на build и вернуть Result, как мы делали с Config::build в проекте ввода-вывода
в листинге 12-9. Но мы решили в данном случае, что попытка создать
пул потоков без потоков должна быть невосстановимой ошибкой. Если вы
чувствуете амбиции, попробуйте написать функцию с именем build со следующей
сигнатурой, чтобы сравнить её с функцией new:
pub fn build(size: usize) -> Result<ThreadPool, PoolCreationError> {
Создание места для хранения потоков
Теперь, когда у нас есть способ узнать, что у нас есть допустимое количество потоков для хранения в
пуле, мы можем создать эти потоки и сохранить их в структуре ThreadPool
перед возвратом структуры. Но как «сохранить» поток? Давайте ещё раз
взглянем на сигнатуру thread::spawn:
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
F: FnOnce() -> T,
F: Send + 'static,
T: Send + 'static,
Функция spawn возвращает JoinHandle<T>, где T — тип, который возвращает
замыкание. Давайте попробуем использовать JoinHandle и посмотрим, что получится. В нашем
случае замыкания, которые мы передаём в пул потоков, будут обрабатывать соединение
и ничего не возвращать, поэтому T будет единичным типом ().
Код в листинге 21-14 скомпилируется, но пока не создаёт никаких потоков.
Мы изменили определение ThreadPool, чтобы оно содержало вектор
экземпляров thread::JoinHandle<()>, инициализировали вектор с ёмкостью
size, настроили цикл for, который выполнит некоторый код для создания потоков, и
вернули экземпляр ThreadPool, содержащий их.
use std::thread;
pub struct ThreadPool {
threads: Vec<thread::JoinHandle<()>>,
}
impl ThreadPool {
// --snip--
/// Создаёт новый ThreadPool.
///
/// size — количество потоков в пуле.
///
/// # Panics
///
/// Функция `new` вызовет панику, если size равен нулю.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let mut threads = Vec::with_capacity(size);
for _ in 0..size {
// создаём несколько потоков и сохраняем их в векторе
}
ThreadPool { threads }
}
// --snip--
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
ThreadPool для хранения потоковМы ввели std::thread в область видимости в библиотечном крейте, потому что
используем thread::JoinHandle в качестве типа элементов вектора в
ThreadPool.
Получив допустимый размер, наш ThreadPool создаёт новый вектор, который может
содержать size элементов. Функция with_capacity выполняет ту же задачу, что и
Vec::new, но с важным отличием: она предварительно выделяет место в
векторе. Поскольку мы знаем, что нам нужно сохранить size элементов в векторе, эта
предварительная аллокация немного эффективнее, чем использование Vec::new,
которое изменяет размер по мере вставки элементов.
Когда вы снова запустите cargo check, он должен завершиться успешно.
Отправка кода из ThreadPool в поток
Мы оставили комментарий в цикле for в листинге 21-14 относительно создания
потоков. Здесь мы рассмотрим, как на самом деле создавать потоки. Стандартная
библиотека предоставляет thread::spawn как способ создания потоков, и
thread::spawn ожидает получить некоторый код, который поток должен запустить сразу после
создания. Однако в нашем случае мы хотим создать потоки и заставить
их ждать кода, который мы отправим позже. Реализация потоков в стандартной библиотеке
не включает никакого способа сделать это; нам нужно реализовать это вручную.
Мы реализуем это поведение, введя новую структуру данных между
ThreadPool и потоками, которая будет управлять этим новым поведением. Мы назовём
эту структуру данных Worker, что является распространённым термином в реализациях
пулов. Worker забирает код, который нужно выполнить, и выполняет
код в своём потоке.
Представьте людей, работающих на кухне ресторана: работники ждут, пока поступят заказы от клиентов, а затем они отвечают за приём этих заказов и их выполнение.
Вместо хранения вектора экземпляров JoinHandle<()> в пуле потоков
мы будем хранить экземпляры структуры Worker. Каждый Worker будет хранить один
экземпляр JoinHandle<()>. Затем мы реализуем метод у Worker, который
будет принимать замыкание кода для выполнения и отправлять его в уже запущенный поток для
выполнения. Мы также дадим каждому Worker id, чтобы можно было различать
разные экземпляры Worker в пуле при журналировании или
отладке.
Вот новый процесс, который будет происходить при создании ThreadPool. Мы
реализуем код, который отправляет замыкание в поток, после того как настроим Worker
таким образом:
- Определить структуру
Worker, которая хранитidиJoinHandle<()>. - Изменить
ThreadPool, чтобы он хранил вектор экземпляровWorker. - Определить функцию
Worker::new, которая принимает номерidи возвращает экземплярWorker, содержащийidи поток, порождённый с пустым замыканием. - В
ThreadPool::newиспользовать счётчик циклаforдля генерацииid, создать новыйWorkerс этимidи сохранитьWorkerв векторе.
Если готовы к вызову, попробуйте реализовать эти изменения самостоятельно, прежде чем смотреть на код в листинге 21-15.
Готовы? Вот листинг 21-15 с одним из способов внесения предыдущих изменений.
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
}
impl ThreadPool {
// --snip--
/// Создаёт новый ThreadPool.
///
/// size — количество потоков в пуле.
///
/// # Panics
///
/// Функция `new` вызовет панику, если size равен нулю.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id));
}
ThreadPool { workers }
}
// --snip--
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
impl Worker {
fn new(id: usize) -> Worker {
let thread = thread::spawn(|| {});
Worker { id, thread }
}
}
ThreadPool для хранения экземпляров Worker вместо хранения потоков напрямуюМы изменили имя поля у ThreadPool с threads на workers,
потому что теперь оно хранит экземпляры Worker вместо экземпляров JoinHandle<()>.
Мы используем счётчик в цикле for в качестве аргумента для
Worker::new и сохраняем каждый новый Worker в векторе с именем workers.
Внешнему коду (как нашему серверу в src/main.rs) не нужно знать детали
реализации, касающиеся использования структуры Worker внутри ThreadPool,
поэтому мы делаем структуру Worker и её функцию new приватными. Функция
Worker::new использует id, который мы ей даём, и сохраняет экземпляр JoinHandle<()>,
который создаётся порождением нового потока с использованием пустого замыкания.
Примечание: если операционная система не может создать поток, потому что не хватает
системных ресурсов, thread::spawn запаникует. Это вызовет панику
всего нашего сервера, даже если создание некоторых потоков может
успешно завершиться. Для простоты такое поведение приемлемо, но в производственной
реализации пула потоков, скорее всего, захотелось бы использовать
std::thread::Builder и его
spawn метод, который возвращает Result вместо этого.
Этот код скомпилируется и сохранит указанное в качестве аргумента ThreadPool::new
количество экземпляров Worker. Но мы по-прежнему не обрабатываем
замыкание, которое получаем в execute. Давайте посмотрим, как это сделать дальше.
Отправка запросов в потоки через каналы
Следующая проблема, которую мы решим, заключается в том, что замыкания, переданные в thread::spawn,
абсолютно ничего не делают. Сейчас мы получаем замыкание, которое хотим выполнить, в
методе execute. Но нам нужно дать thread::spawn замыкание для запуска, когда мы
создаём каждый Worker во время создания ThreadPool.
Мы хотим, чтобы только что созданные нами структуры Worker получали код для выполнения из
очереди, хранящейся в ThreadPool, и отправляли этот код в свой поток для выполнения.
Каналы, о которых мы узнали в главе 16 — простой способ связи между
двумя потоками — идеально подошли бы для этого случая использования. Мы будем использовать канал в качестве
очереди задач, и execute будет отправлять задачу из ThreadPool в
экземпляры Worker, которые отправят задачу в свой поток. Вот план:
ThreadPoolсоздаст канал и сохранит отправителя.- Каждый
Workerбудет хранить получателя. - Мы создадим новую структуру
Job, которая будет хранить замыкания, которые мы хотим отправить по каналу. - Метод
executeбудет отправлять задачу, которую хочет выполнить, через отправителя. - В своём потоке
Workerбудет перебирать получателя в цикле и выполнять замыкания любых полученных задач.
Давайте начнём с создания канала в ThreadPool::new и сохранения отправителя
в экземпляре ThreadPool, как показано в листинге 21-16. Структура Job
пока ничего не хранит, но будет типом элемента, который мы отправляем по
каналу.
use std::{sync::mpsc, thread};
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
struct Job;
impl ThreadPool {
// --snip--
/// Создаёт новый ThreadPool.
///
/// size — количество потоков в пуле.
///
/// # Panics
///
/// Функция `new` вызовет панику, если size равен нулю.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id));
}
ThreadPool { workers, sender }
}
// --snip--
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
impl Worker {
fn new(id: usize) -> Worker {
let thread = thread::spawn(|| {});
Worker { id, thread }
}
}
ThreadPool для хранения отправителя канала, который передаёт экземпляры JobВ ThreadPool::new мы создаём наш новый канал и заставляем пул хранить
отправителя. Это успешно скомпилируется.
Давайте попробуем передать получателя канала в каждый Worker, когда
пул потоков создаёт канал. Мы знаем, что хотим использовать получателя в потоке,
который порождают экземпляры Worker, поэтому мы будем ссылаться на параметр receiver в
замыкании. Код в листинге 21-17 пока не скомпилируется.
use std::{sync::mpsc, thread};
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
struct Job;
impl ThreadPool {
// --snip--
/// Создаёт новый ThreadPool.
///
/// size — количество потоков в пуле.
///
/// # Panics
///
/// Функция `new` вызовет панику, если size равен нулю.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, receiver));
}
ThreadPool { workers, sender }
}
// --snip--
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
// --snip--
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
impl Worker {
fn new(id: usize, receiver: mpsc::Receiver<Job>) -> Worker {
let thread = thread::spawn(|| {
receiver;
});
Worker { id, thread }
}
}
WorkerМы сделали некоторые небольшие и простые изменения: мы передаём получателя в
Worker::new, а затем используем его внутри замыкания.
Когда мы попытаемся проверить этот код, мы получим эту ошибку:
$ cargo check
Checking hello v0.1.0 (file:///projects/hello)
error[E0382]: use of moved value: `receiver`
--> src/lib.rs:26:42
|
21 | let (sender, receiver) = mpsc::channel();
| -------- move occurs because `receiver` has type `std::sync::mpsc::Receiver<Job>`, which does not implement the `Copy` trait
...
25 | for id in 0..size {
| ----------------- inside of this loop
26 | workers.push(Worker::new(id, receiver));
| ^^^^^^^^ value moved here, in previous iteration of loop
|
note: consider changing this parameter type in method `new` to borrow instead if owning the value isn't necessary
--> src/lib.rs:47:33
|
47 | fn new(id: usize, receiver: mpsc::Receiver<Job>) -> Worker {
| --- in this method ^^^^^^^^^^^^^^^^^^^ this parameter takes ownership of the value
For more information about this error, try `rustc --explain E0382`.
error: could not compile `hello` (lib) due to 1 previous error
Код пытается передать receiver нескольким экземплярам Worker. Это
не сработает, как вы помните из главы 16: реализация каналов, которую
предоставляет Rust, — это multiple producer, single consumer (множественные производители, единственный потребитель). Это означает, что мы не можем
просто клонировать потребляющий конец канала, чтобы исправить этот код. Мы также не
хотим отправлять сообщение несколько раз нескольким потребителям; мы хотим один список
сообщений с несколькими экземплярами Worker, так чтобы каждое сообщение
обрабатывалось один раз.
Кроме того, извлечение задачи из очереди канала включает изменение
receiver, поэтому потокам нужен безопасный способ совместного использования и изменения receiver;
в противном случае мы могли бы получить гонки данных (как обсуждалось в главе 16).
Вспомните потокобезопасные умные указатели, обсуждавшиеся в главе 16: чтобы совместно использовать
владение между несколькими потоками и позволить потокам изменять значение, нам
нужно использовать Arc<Mutex<T>>. Тип Arc позволит нескольким экземплярам Worker
владеть получателем, а Mutex обеспечит, что только один Worker получит задачу из
получателя за раз. Листинг 21-18 показывает изменения, которые нужно внести.
use std::{
sync::{Arc, Mutex, mpsc},
thread,
};
// --snip--
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
struct Job;
impl ThreadPool {
// --snip--
/// Создаёт новый ThreadPool.
///
/// size — количество потоков в пуле.
///
/// # Panics
///
/// Функция `new` вызовет панику, если size равен нулю.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
// --snip--
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
// --snip--
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
// --snip--
let thread = thread::spawn(|| {
receiver;
});
Worker { id, thread }
}
}
Worker с помощью Arc и MutexВ ThreadPool::new мы помещаем получателя в Arc и Mutex. Для каждого
нового Worker мы клонируем Arc, чтобы увеличить счётчик ссылок, так что
экземпляры Worker могут совместно владеть получателем.
С этими изменениями код компилируется! Мы приближаемся!
Реализация метода execute
Давайте наконец реализуем метод execute у ThreadPool. Мы также изменим
Job со структуры на псевдоним типа для трейт-объекта, который хранит тип
замыкания, которое получает execute. Как обсуждалось в разделе «Синонимы типов и псевдонимы
типов» в главе 20, псевдонимы типов
позволяют нам сделать длинные типы короче для удобства использования. Посмотрите на листинг 21-19.
use std::{
sync::{Arc, Mutex, mpsc},
thread,
};
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
// --snip--
type Job = Box<dyn FnOnce() + Send + 'static>;
impl ThreadPool {
// --snip--
/// Создаёт новый ThreadPool.
///
/// size — количество потоков в пуле.
///
/// # Panics
///
/// Функция `new` вызовет панику, если size равен нулю.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(job).unwrap();
}
}
// --snip--
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
let thread = thread::spawn(|| {
receiver;
});
Worker { id, thread }
}
}
Job для Box, который хранит каждое замыкание, и последующая отправка задачи по каналуПосле создания нового экземпляра Job с использованием замыкания, которое мы получаем в execute, мы
отправляем эту задачу по отправляющему концу канала. Мы вызываем unwrap на
send на случай, если отправка завершится неудачей. Это может произойти, например, если мы
остановим выполнение всех наших потоков, что означает, что принимающий конец перестал
получать новые сообщения. На данный момент мы не можем остановить наши потоки от
выполнения: наши потоки продолжают выполняться, пока существует пул. Причина, по которой мы используем unwrap, в том, что мы знаем, что сценарий отказа не произойдёт, но
компилятор этого не знает.
Но мы ещё не совсем закончили! В Worker наше замыкание, передаваемое в
thread::spawn, по-прежнему только ссылается на принимающий конец канала.
Вместо этого нам нужно, чтобы замыкание бесконечно зацикливалось, запрашивая у принимающего конца
канала задачу и выполняя задачу, когда она получена. Давайте внесём изменение,
показанное в листинге 21-20, в Worker::new.
use std::{
sync::{Arc, Mutex, mpsc},
thread,
};
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
type Job = Box<dyn FnOnce() + Send + 'static>;
impl ThreadPool {
/// Создаёт новый ThreadPool.
///
/// size — количество потоков в пуле.
///
/// # Panics
///
/// Функция `new` вызовет панику, если size равен нулю.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(job).unwrap();
}
}
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
// --snip--
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
let thread = thread::spawn(move || {
loop {
let job = receiver.lock().unwrap().recv().unwrap();
println!("Worker {id} got a job; executing.");
job();
}
});
Worker { id, thread }
}
}
WorkerЗдесь мы сначала вызываем lock у receiver, чтобы получить мьютекс, а затем
вызываем unwrap, чтобы вызвать панику при любых ошибках. Получение блокировки может завершиться неудачей, если мьютекс
находится в отравленном состоянии, что может произойти, если какой-либо другой поток запаниковал, удерживая
блокировку, вместо того чтобы освободить её. В этой ситуации вызов
unwrap, чтобы этот поток запаниковал, — правильное действие. Не стесняйтесь
заменить этот unwrap на expect с сообщением об ошибке, которое имеет смысл
для вас.
Если мы получаем блокировку мьютекса, мы вызываем recv, чтобы получить Job из
канала. Последний unwrap также проходит мимо любых ошибок здесь, которые могут возникнуть,
если поток, удерживающий отправителя, завершился, аналогично тому, как метод send
возвращает Err, если получатель завершился.
Вызов recv блокируется, поэтому, если задачи ещё нет, текущий поток
будет ждать, пока задача не станет доступной. Mutex<T> гарантирует, что только один
поток Worker за раз пытается запросить задачу.
Наш пул потоков теперь находится в рабочем состоянии! Запустите cargo run и сделайте несколько
запросов:
$ cargo run
Compiling hello v0.1.0 (file:///projects/hello)
warning: field `workers` is never read
--> src/lib.rs:7:5
|
6 | pub struct ThreadPool {
| ---------- field in this struct
7 | workers: Vec<Worker>,
| ^^^^^^^
|
= note: `#[warn(dead_code)]` on by default
warning: fields `id` and `thread` are never read
--> src/lib.rs:48:5
|
47 | struct Worker {
| ------ fields in this struct
48 | id: usize,
| ^^
49 | thread: thread::JoinHandle<()>,
| ^^^^^^
warning: `hello` (lib) generated 2 warnings
Finished `dev` profile [unoptimized + debuginfo] target(s) in 4.91s
Running `target/debug/hello`
Worker 0 got a job; executing.
Worker 2 got a job; executing.
Worker 1 got a job; executing.
Worker 3 got a job; executing.
Worker 0 got a job; executing.
Worker 2 got a job; executing.
Worker 1 got a job; executing.
Worker 3 got a job; executing.
Worker 0 got a job; executing.
Worker 2 got a job; executing.
Успех! Теперь у нас есть пул потоков, который выполняет соединения асинхронно. Создаётся никогда не более четырёх потоков, поэтому наша система не будет перегружена, если сервер получит много запросов. Если мы сделаем запрос к /sleep, сервер сможет обслуживать другие запросы, запустив их в другом потоке.
Примечание: если открыть /sleep в нескольких окнах браузера одновременно, они могут загружаться по одному с интервалом в пять секунд. Некоторые веб-браузеры выполняют несколько экземпляров одного и того же запроса последовательно по причинам кэширования. Это ограничение не вызвано нашим веб-сервером.
Хорошее время, чтобы остановиться и подумать о том, как код в листингах 21-18, 21-19 и 21-20 отличался бы, если бы мы использовали фьючерсы вместо замыкания для выполняемой работы. Какие типы изменились бы? Как бы отличались сигнатуры методов, если вообще отличались бы? Какие части кода остались бы прежними?
После изучения цикла while let в главе 17 и главе 19, вы
можете задаться вопросом, почему мы не написали код потока Worker так, как показано в
листинге 21-21.
use std::{
sync::{Arc, Mutex, mpsc},
thread,
};
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
type Job = Box<dyn FnOnce() + Send + 'static>;
impl ThreadPool {
/// Создаёт новый ThreadPool.
///
/// size — количество потоков в пуле.
///
/// # Panics
///
/// Функция `new` вызовет панику, если size равен нулю.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(job).unwrap();
}
}
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
// --snip--
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
let thread = thread::spawn(move || {
while let Ok(job) = receiver.lock().unwrap().recv() {
println!("Worker {id} got a job; executing.");
job();
}
});
Worker { id, thread }
}
}
Worker::new с использованием while letЭтот код компилируется и выполняется, но не приводит к желаемому поведению
потоков: медленный запрос по-прежнему будет заставлять другие запросы ждать
обработки. Причина несколько тонкая: у структуры Mutex нет публичного
метода unlock, потому что владение блокировкой основано на времени жизни
MutexGuard<T> внутри LockResult<MutexGuard<T>>, который возвращает метод lock.
Во время компиляции проверка заимствований может затем обеспечить соблюдение правила,
что к ресурсу, защищённому Mutex, нельзя получить доступ, если мы не удерживаем
блокировку. Однако эта реализация также может привести к тому, что блокировка будет удерживаться
дольше, чем предполагалось, если мы не будем внимательны ко времени жизни
MutexGuard<T>.
Код в листинге 21-20, использующий let job = receiver.lock().unwrap().recv().unwrap();, работает, потому что с let любые
временные значения, используемые в выражении в правой части знака
равно, немедленно уничтожаются, когда инструкция let завершается. Однако while let (и if let и
match) не уничтожает временные значения до конца
связанного блока. В листинге 21-21 блокировка остаётся удерживаемой на протяжении
вызова job(), что означает, что другие экземпляры Worker не могут получать задачи.