Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Корректное завершение работы и очистка

Код в листинге 21-20 отвечает на запросы асинхронно через использование пула потоков, как мы и задумывали. Мы получаем несколько предупреждений о полях workers, id и thread, которые мы не используем напрямую, что напоминает нам, что мы ничего не очищаем. Когда мы используем менее элегантный метод ctrl-C для остановки главного потока, все остальные потоки также немедленно останавливаются, даже если они находятся в середине обслуживания запроса.

Далее мы реализуем трейт Drop, чтобы вызвать join для каждого из потоков в пуле, чтобы они могли завершить запросы, над которыми работают, прежде чем закрыться. Затем мы реализуем способ сообщить потокам, что им следует прекратить принимать новые запросы и завершиться. Чтобы увидеть этот код в действии, мы изменим наш сервер так, чтобы он принимал только два запроса, прежде чем плавно завершить работу своего пула потоков.

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

Реализация трейта Drop для ThreadPool

Давайте начнём с реализации Drop для нашего пула потоков. Когда пул удаляется, все наши потоки должны присоединиться, чтобы убедиться, что они завершили свою работу. В листинге 21-22 показана первая попытка реализации Drop; этот код ещё не совсем работает.

Имя файла: src/lib.rs
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();
    }
}

impl Drop for ThreadPool {
    fn drop(&mut self) {
        for worker in &mut self.workers {
            println!("Shutting down worker {}", worker.id);

            worker.thread.join().unwrap();
        }
    }
}

struct Worker {
    id: usize,
    thread: thread::JoinHandle<()>,
}

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 }
    }
}
Листинг 21-22: Присоединение каждого потока, когда пул потоков выходит из области видимости

Сначала мы перебираем каждого из workers пула потоков. Мы используем &mut для этого, потому что self — изменяемая ссылка, и нам также нужно иметь возможность изменять worker. Для каждого worker мы выводим сообщение о том, что этот конкретный экземпляр Worker завершается, а затем вызываем join для потока этого экземпляра Worker. Если вызов join завершается неудачей, мы используем unwrap, чтобы заставить Rust запаниковать и перейти к неграциозному завершению.

Вот ошибка, которую мы получаем при компиляции этого кода:

$ cargo check
    Checking hello v0.1.0 (file:///projects/hello)
error[E0507]: cannot move out of `worker.thread` which is behind a mutable reference
  --> src/lib.rs:52:13
   |
52 |             worker.thread.join().unwrap();
   |             ^^^^^^^^^^^^^ ------ `worker.thread` moved due to this method call
   |             |
   |             move occurs because `worker.thread` has type `JoinHandle<()>`, which does not implement the `Copy` trait
   |
note: `JoinHandle::<T>::join` takes ownership of the receiver `self`, which moves `worker.thread`
  --> /rustc/2d8144b7880597b6e6d3dfd63a9a9efae3f533d3/library/std/src/thread/join_handle.rs:149:16

For more information about this error, try `rustc --explain E0507`.
error: could not compile `hello` (lib) due to 1 previous error

Ошибка сообщает нам, что мы не можем вызвать join, потому что у нас есть только изменяемое заимствование каждого worker, а join становится владельцем своего аргумента. Чтобы решить эту проблему, нам нужно вынести поток из экземпляра Worker, которому принадлежит thread, чтобы join мог потребить поток. Один из способов сделать это — использовать тот же подход, который мы использовали в листинге 18-15. Если бы Worker содержал Option<thread::JoinHandle<()>>, мы могли бы вызвать метод take для Option, чтобы вынести значение из варианта Some и оставить на его месте вариант None. Другими словами, Worker, который выполняется, имел бы вариант Some в thread, а когда мы хотели бы очистить Worker, мы бы заменили Some на None, чтобы у Worker не было потока для выполнения.

Однако единственный раз, когда это возникло бы, — это при удалении Worker. Взамен нам пришлось бы иметь дело с Option<thread::JoinHandle<()>> везде, где мы обращались бы к worker.thread. Идиоматический Rust довольно часто использует Option, но когда вы обнаруживаете, что оборачиваете что-то, что, как вы знаете, всегда будет присутствовать, в Option в качестве обходного решения, стоит поискать альтернативные подходы, чтобы сделать ваш код чище и менее подверженным ошибкам.

В этом случае существует лучшая альтернатива: метод Vec::drain. Он принимает параметр диапазона, чтобы указать, какие элементы удалить из вектора, и возвращает итератор по этим элементам. Передача синтаксиса диапазона .. удалит каждое значение из вектора.

Итак, нам нужно обновить реализацию drop для ThreadPool вот так:

Имя файла: src/lib.rs
#![allow(unused)]
fn main() {
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();
    }
}

impl Drop for ThreadPool {
    fn drop(&mut self) {
        for worker in self.workers.drain(..) {
            println!("Shutting down worker {}", worker.id);

            worker.thread.join().unwrap();
        }
    }
}

struct Worker {
    id: usize,
    thread: thread::JoinHandle<()>,
}

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 }
    }
}
}

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

Сигнализация потокам о необходимости прекратить прослушивание заданий

Со всеми внесёнными изменениями наш код компилируется без предупреждений. Однако плохая новость в том, что этот код пока не функционирует так, как мы хотим. Ключ — в логике замыканий, выполняемых потоками экземпляров Worker: на данный момент мы вызываем join, но это не остановит потоки, потому что они loop вечно в поисках заданий. Если мы попытаемся удалить наш ThreadPool с текущей реализацией drop, главный поток заблокируется навсегда, ожидая завершения первого потока.

Чтобы решить эту проблему, нам нужно изменить реализацию drop для ThreadPool и затем изменить цикл в Worker.

Сначала мы изменим реализацию drop для ThreadPool, чтобы явно удалить sender перед ожиданием завершения потоков. Листинг 21-23 показывает изменения в ThreadPool для явного удаления sender. В отличие от потока, здесь нам нужно использовать Option, чтобы иметь возможность вынести sender из ThreadPool с помощью Option::take.

Имя файла: src/lib.rs
use std::{
    sync::{Arc, Mutex, mpsc},
    thread,
};

pub struct ThreadPool {
    workers: Vec<Worker>,
    sender: Option<mpsc::Sender<Job>>,
}
// --snip--

type Job = Box<dyn FnOnce() + Send + 'static>;

impl ThreadPool {
    /// Создаёт новый ThreadPool.
    ///
    /// size — количество потоков в пуле.
    ///
    /// # Panics
    ///
    /// Функция `new` вызовет панику, если size равен нулю.
    pub fn new(size: usize) -> ThreadPool {
        // --snip--

        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: Some(sender),
        }
    }

    pub fn execute<F>(&self, f: F)
    where
        F: FnOnce() + Send + 'static,
    {
        let job = Box::new(f);

        self.sender.as_ref().unwrap().send(job).unwrap();
    }
}

impl Drop for ThreadPool {
    fn drop(&mut self) {
        drop(self.sender.take());

        for worker in self.workers.drain(..) {
            println!("Shutting down worker {}", worker.id);

            worker.thread.join().unwrap();
        }
    }
}

struct Worker {
    id: usize,
    thread: thread::JoinHandle<()>,
}

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 }
    }
}
Листинг 21-23: Явное удаление sender перед присоединением потоков Worker

Удаление sender закрывает канал, что означает, что больше сообщений не будет отправлено. Когда это происходит, все вызовы recv, которые делают экземпляры Worker в бесконечном цикле, вернут ошибку. В листинге 21-24 мы изменяем цикл Worker, чтобы плавно выйти из цикла в этом случае, что означает, что потоки завершатся, когда реализация drop для ThreadPool вызовет join для них.

Имя файла: src/lib.rs
use std::{
    sync::{Arc, Mutex, mpsc},
    thread,
};

pub struct ThreadPool {
    workers: Vec<Worker>,
    sender: Option<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: Some(sender),
        }
    }

    pub fn execute<F>(&self, f: F)
    where
        F: FnOnce() + Send + 'static,
    {
        let job = Box::new(f);

        self.sender.as_ref().unwrap().send(job).unwrap();
    }
}

impl Drop for ThreadPool {
    fn drop(&mut self) {
        drop(self.sender.take());

        for worker in self.workers.drain(..) {
            println!("Shutting down worker {}", worker.id);

            worker.thread.join().unwrap();
        }
    }
}

struct Worker {
    id: usize,
    thread: thread::JoinHandle<()>,
}

impl Worker {
    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
        let thread = thread::spawn(move || {
            loop {
                let message = receiver.lock().unwrap().recv();

                match message {
                    Ok(job) => {
                        println!("Worker {id} got a job; executing.");

                        job();
                    }
                    Err(_) => {
                        println!("Worker {id} disconnected; shutting down.");
                        break;
                    }
                }
            }
        });

        Worker { id, thread }
    }
}
Листинг 21-24: Явный выход из цикла, когда recv возвращает ошибку

Чтобы увидеть этот код в действии, давайте изменим main, чтобы принимать только два запроса перед плавным завершением работы сервера, как показано в листинге 21-25.

Имя файла: 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().take(2) {
        let stream = stream.unwrap();

        pool.execute(|| {
            handle_connection(stream);
        });
    }

    println!("Shutting down.");
}

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();
}
Листинг 21-25: Завершение работы сервера после обслуживания двух запросов путём выхода из цикла

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

Метод take определён в трейте Iterator и ограничивает итерацию первыми двумя элементами максимум. ThreadPool выйдет из области видимости в конце main, и реализация drop будет выполнена.

Запустите сервер с помощью cargo run и сделайте три запроса. Третий запрос должен вернуть ошибку, и в вашем терминале вы должны увидеть вывод, аналогичный этому:

$ cargo run
   Compiling hello v0.1.0 (file:///projects/hello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.41s
     Running `target/debug/hello`
Worker 0 got a job; executing.
Shutting down.
Shutting down worker 0
Worker 3 got a job; executing.
Worker 1 disconnected; shutting down.
Worker 2 disconnected; shutting down.
Worker 3 disconnected; shutting down.
Worker 0 disconnected; shutting down.
Shutting down worker 1
Shutting down worker 2
Shutting down worker 3

Вы можете увидеть другой порядок выводимых ID и сообщений Worker. По сообщениям мы можем увидеть, как работает этот код: экземпляры Worker 0 и 3 получили первые два запроса. Сервер перестал принимать соединения после второго соединения, и реализация Drop для ThreadPool начала выполняться до того, как Worker 3 даже начал свою работу. Удаление sender отключает все экземпляры Worker и сообщает им о необходимости завершиться. Каждый экземпляр Worker выводит сообщение, когда отключается, а затем пул потоков вызывает join, чтобы дождаться завершения каждого потока Worker.

Обратите внимание на один интересный аспект этого конкретного выполнения: ThreadPool удалил sender, и прежде чем какой-либо Worker получил ошибку, мы попытались присоединить Worker 0. Worker 0 ещё не получил ошибку от recv, поэтому главный поток заблокировался, ожидая завершения Worker 0. Тем временем Worker 3 получил задание, а затем все потоки получили ошибку. Когда Worker 0 завершился, главный поток подождал остальные экземпляры Worker, чтобы они завершились. На тот момент они все вышли из своих циклов и остановились.

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

Вот полный код для справки:

Имя файла: 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().take(2) {
        let stream = stream.unwrap();

        pool.execute(|| {
            handle_connection(stream);
        });
    }

    println!("Shutting down.");
}

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();
}
Имя файла: src/lib.rs
use std::{
    sync::{Arc, Mutex, mpsc},
    thread,
};

pub struct ThreadPool {
    workers: Vec<Worker>,
    sender: Option<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: Some(sender),
        }
    }

    pub fn execute<F>(&self, f: F)
    where
        F: FnOnce() + Send + 'static,
    {
        let job = Box::new(f);

        self.sender.as_ref().unwrap().send(job).unwrap();
    }
}

impl Drop for ThreadPool {
    fn drop(&mut self) {
        drop(self.sender.take());

        for worker in &mut self.workers {
            println!("Shutting down worker {}", worker.id);

            if let Some(thread) = worker.thread.take() {
                thread.join().unwrap();
            }
        }
    }
}

struct Worker {
    id: usize,
    thread: Option<thread::JoinHandle<()>>,
}

impl Worker {
    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
        let thread = thread::spawn(move || {
            loop {
                let message = receiver.lock().unwrap().recv();

                match message {
                    Ok(job) => {
                        println!("Worker {id} got a job; executing.");

                        job();
                    }
                    Err(_) => {
                        println!("Worker {id} disconnected; shutting down.");
                        break;
                    }
                }
            }
        });

        Worker {
            id,
            thread: Some(thread),
        }
    }
}

Здесь можно сделать больше! Если вы хотите продолжить улучшать этот проект, вот несколько идей:

  • Добавить больше документации к ThreadPool и его публичным методам.
  • Добавить тесты функциональности библиотеки.
  • Заменить вызовы unwrap на более надёжную обработку ошибок.
  • Использовать ThreadPool для выполнения какой-либо задачи, отличной от обслуживания веб-запросов.
  • Найти крейт пула потоков на crates.io и реализовать аналогичный веб-сервер с использованием этого крейта. Затем сравните его API и надёжность с пулом потоков, который мы реализовали.

Итоги

Отлично! Вы дошли до конца книги! Мы хотим поблагодарить вас за то, что вы присоединились к нам в этом путешествии по Rust. Теперь вы готовы реализовывать собственные проекты на Rust и помогать другим людям с их проектами. Помните, что существует гостеприимное сообщество других Rustaceans, которые с радостью помогут вам с любыми проблемами, с которыми вы столкнётесь на своём пути в Rust.