การปิดระบบอย่างนุ่มนวลและการทำความสะอาด
โค้ดในลิสติ้ง 21-20 สามารถตอบสนองต่อคำขอ (requests) แบบอะซิงโครนัสผ่านการใช้พูลเธรด (thread pool) ได้ตามที่เราตั้งใจไว้แล้ว ทว่าเรายังได้รับคำเตือน (warnings) เกี่ยวกับฟิลด์ workers, id และ thread ที่เราไม่ได้เรียกใช้งานโดยตรง ซึ่งคอยเตือนสติเราว่าเรายังไม่ได้เขียนโค้ดสำหรับเก็บกวาดทำความสะอาดทรัพยากรเลยแม้แต่น้อย ยิ่งไปกว่านั้น เมื่อเราหยุดการทำงานของเธรดหลักด้วยวิธีที่ค่อนข้างหยาบอย่างการกด ctrl-C เธรดอื่น ๆ ทั้งหมดก็จะถูกสั่งหยุดทำงานอย่างกะทันหันในทันที แม้ว่าพวกมันกำลังอยู่ระหว่างการประมวลผลคำขอค้างอยู่ก็ตาม
ในลำดับถัดไป เราจะอิมพลีเมนต์เทรต Drop เพื่อเรียกใช้ join กับแต่ละเธรดในพูล เพื่อเปิดโอกาสให้พวกมันประมวลผลคำขอที่ค้างอยู่ให้เสร็จสิ้นก่อนที่จะปิดตัวลง จากนั้นเราจะสร้างกลไกส่งสัญญาณบอกเธรดต่าง ๆ ว่าพวกมันควรหยุดรับคำขอใหม่และเริ่มปิดตัวลง และเพื่อทดสอบการทำงานของโค้ดนี้ในสถานการณ์จริง เราจะปรับแก้เซิร์ฟเวอร์ของเราให้รับคำขอเพียง 2 ครั้งก่อนจะปิดการทำงานของพูลเธรดลงอย่างนุ่มนวล (graceful shutdown)
ข้อสังเกตประการหนึ่งขณะที่เรากำลังดำเนินการคือ สิ่งเหล่านี้ไม่มีผลกระทบต่อส่วนของโค้ดที่จัดการการรันโคลเชอร์เลย ดังนั้นทุกสิ่งที่เรากำลังจะทำตรงนี้จะยังคงเหมือนเดิมทุกประการหากเรานำพูลเธรดไปประยุกต์ใช้กับรันไทม์แบบ async
การอิมพลีเมนต์เทรต Drop บน ThreadPool
มาเริ่มต้นด้วยการอิมพลีเมนต์เทรต Drop ให้กับพูลเธรดของเรา เมื่อพูลถูกทำลายทิ้ง (drop) เธรดทั้งหมดควรทำการ join เพื่อให้มั่นใจว่าพวกมันประมวลผลงานจนเสร็จสมบูรณ์ ลิสติ้ง 21-22 แสดงความพยายามแรกในการอิมพลีเมนต์ Drop ซึ่งโค้ดนี้จะยังคอมไพล์ไม่ผ่าน
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 {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
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 }
}
}
เริ่มแรก เราวนลูปผ่านแต่ละ workers ของพูลเธรด โดยเราใช้ &mut เนื่องจาก self เป็นการอ้างอิงแบบปรับเปลี่ยนค่าได้ (mutable reference) และเราจำเป็นต้องแก้ไขค่าของ 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/88d9e12ae178fab0fb5cc050a94da85685d449ea/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 ได้ เนื่องจากเราถือเพียงการยืมแบบปรับเปลี่ยนค่าได้ (mutable borrow) ของ worker แต่ละตัวเท่านั้น ในขณะที่ join จำเป็นต้องรับสิทธิ์ความเป็นเจ้าของ (ownership) ในอาร์กิวเมนต์ของมัน เพื่อแก้ปัญหานี้ เราต้องย้ายเธรดออกจากอินสแตนซ์ Worker ที่เป็นเจ้าของฟิลด์ thread นั้น เพื่อให้ join สามารถดึงข้อมูลเธรดไปใช้งานจนหมดได้ แนวทางหนึ่งคือการใช้วิธีเดียวกับที่เราเคยทำในลิสติ้ง 18-15 หาก Worker จัดเก็บข้อมูลเป็น Option<thread::JoinHandle<()>> เราจะสามารถเรียกเมธอด take บน Option เพื่อย้ายค่าออกจากตัวแปรแบบ Some และทิ้งค่า None ไว้แทนที่ได้ กล่าวคือ Worker ที่ยังทำงานอยู่จะมีค่าเป็น Some อยู่ใน thread และเมื่อเราต้องการเก็บกวาดทำความสะอาด Worker เราจะแทนที่ค่านั้นด้วย None เพื่อให้ Worker ไม่มีเธรดหลงเหลือให้รันอีกต่อไป
อย่างไรก็ตาม จังหวะ เพียงครั้งเดียว ที่เหตุการณ์นี้จะเกิดขึ้นก็คือตอนทำลาย (drop) Worker เท่านั้น แต่เรากลับต้องแลกมาด้วยการคอยจัดการกับ Option<thread::JoinHandle<()>> ในทุก ๆ จุดที่เราเข้าถึง worker.thread แม้ว่าตามสำนวนนิยมของ Rust จะมีการใช้ Option อยู่บ่อยครั้ง แต่หากคุณพบว่าตนเองต้องนำ Option มาห่อหุ้มสิ่งที่คุณรู้อยู่แก่ใจว่ามันมีค่าอยู่เสมอเพียงเพื่อเป็นทางแก้ขัดเช่นนี้ การมองหาแนวทางอื่นเพื่อช่วยให้โค้ดของคุณสะอาดและลดโอกาสเกิดข้อผิดพลาดได้ดีกว่าย่อมเป็นทางเลือกที่เหมาะสมกว่า
ในกรณีนี้ เรามีทางเลือกที่ดีกว่า นั่นคือการใช้เมธอด Vec::drain ซึ่งรับพารามิเตอร์เป็นช่วง (range) เพื่อระบุว่าจะดึงสมาชิกตัวใดออกจากเวกเตอร์บ้าง และจะคืนค่ากลับมาเป็นอิเทอเรเตอร์ของสมาชิกเหล่านั้น โดยการส่งไวยากรณ์ช่วง .. จะเป็นการดึง ทุกค่า ออกจากเวกเตอร์
ดังนั้น เราจึงต้องอัปเดตการอิมพลีเมนต์ drop ของ ThreadPool ดังนี้:
#![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 {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
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 ในจุดนี้จึงอาจเกิดการแพนิกซ้ำซ้อน (double panic) ซึ่งจะส่งผลให้โปรแกรมแครชในทันทีและทำให้กระบวนการเก็บกวาดทรัพยากรที่กำลังดำเนินอยู่ต้องหยุดชะงักลง พฤติกรรมนี้ถือว่ายอมรับได้ในโปรแกรมตัวอย่างสำหรับการเรียนรู้ แต่ไม่แนะนำให้ใช้ในโค้ดระดับโปรดักชันจริง
การส่งสัญญาณให้เธรดหยุดรอฟังงาน
หลังจากการปรับปรุงทั้งหมดที่เราได้ทำไป โค้ดของเราสามารถคอมไพล์ผ่านได้โดยไม่มีคำเตือนใด ๆ หลงเหลือ ทว่าข่าวร้ายคือโค้ดยังไม่ทำงานตามที่เราต้องการอย่างแท้จริง สาเหตุสำคัญอยู่ที่ตรรกะภายในโคลเชอร์ที่รันอยู่บนเธรดของแต่ละ Worker: ในตอนนี้ แม้เราจะสั่งเรียก join แต่นั่นจะไม่ทำให้เธรดปิดการทำงานลงได้ เพราะเธรดเหล่านั้นยังคงวนลูป loop คอยหางาน (job) ไปเรื่อย ๆ อย่างไม่มีที่สิ้นสุด หากเราพยายามทำลาย ThreadPool ทิ้งด้วยการอิมพลีเมนต์ drop ในปัจจุบัน เธรดหลักจะหยุดรอค้าง (block) อยู่ตลอดไปเพื่อรอให้เธรดแรกทำงานเสร็จ
ในการแก้ไขปัญหานี้ เราต้องปรับเปลี่ยนการทำงานของ drop ใน ThreadPool ควบคู่ไปกับการปรับลูปการทำงานของ Worker
ประการแรก เราจะปรับแก้การทำงานของ drop ใน ThreadPool ให้ทำลาย (drop) sender ทิ้งอย่างชัดเจนก่อนที่จะเริ่มรอให้เธรดทำงานเสร็จ ลิสติ้ง 21-23 แสดงการปรับปรุง ThreadPool เพื่อสั่งทำลาย sender อย่างชัดเจน ซึ่งในจุดนี้ต่างจากกรณีของเธรดตรงที่เรา จำเป็น ต้องใช้ Option เพื่อให้สามารถย้ายสิทธิ์ของ sender ออกมาจาก ThreadPool ด้วย Option::take ได้
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 {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
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 }
}
}
การทำลาย sender ทิ้งจะส่งผลให้แชนเนลปิดตัวลง ซึ่งเป็นการส่งสัญญาณบ่งบอกว่าจะไม่มีข้อความใหม่ส่งเข้ามาอีกต่อไป เมื่อเป็นเช่นนั้น การเรียก recv ทั้งหมดที่อินสแตนซ์ Worker ทำอยู่ในลูปอนันต์จะคืนค่าเป็นข้อผิดพลาดกลับมา ในลิสติ้ง 21-24 เราจะปรับลูปการทำงานของ Worker ให้หยุดการทำงานและออกจากลูปอย่างนุ่มนวลเมื่อพบกรณีดังกล่าว ซึ่งหมายความว่าเธรดจะสามารถปิดตัวลงได้อย่างสมบูรณ์เมื่อ drop ของ ThreadPool เรียกใช้ join กับพวกมัน
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 {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
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 }
}
}
เพื่อดูการทำงานของโค้ดนี้ในสถานการณ์จริง มาปรับฟังก์ชัน main ให้รับคำขอเพียง 2 ครั้งก่อนจะปิดเซิร์ฟเวอร์ลงอย่างนุ่มนวล ดังแสดงในลิสติ้ง 21-25
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();
}
แน่นอนว่าในเว็บเซิร์ฟเวอร์ที่ใช้งานจริง คุณคงไม่ต้องการให้เซิร์ฟเวอร์ปิดตัวลงหลังจากให้บริการเพียง 2 คำขอ แต่โค้ดนี้เขียนขึ้นเพื่อสาธิตให้เห็นว่า กลไกการปิดระบบอย่างนุ่มนวลและการเก็บกวาดทรัพยากรทำงานได้อย่างถูกต้องแม่นยำ
เมธอด take ถูกนิยามไว้ในเทรต Iterator โดยทำหน้าที่จำกัดการวนซ้ำให้เหลือไม่เกิน 2 รายการแรก และเมื่อฟังก์ชัน main สิ้นสุดลง ตัวแปร ThreadPool ก็จะหลุดออกจากขอบเขต (scope) ทำให้โค้ดใน drop เริ่มทำงาน
เริ่มรันเซิร์ฟเวอร์ด้วยคำสั่ง cargo run แล้วลองส่งคำขอเข้ามา 3 ครั้ง โดยคำขอที่สามควรได้รับข้อผิดพลาดกลับไป และในหน้าต่างเทอร์มินัลของคุณ คุณจะเห็นข้อความเอาต์พุตคล้ายกับต่อไปนี้:
$ 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 เป็นผู้ได้รับ 2 คำขอแรก จากนั้นเซิร์ฟเวอร์หยุดรับการเชื่อมต่อใหม่หลังจากการเชื่อมต่อที่สองเสร็จสิ้น และการทำงานของ Drop บน ThreadPool ได้เริ่มทำงานขึ้นก่อนที่ Worker 3 จะเริ่มประมวลผลงานของมันเสียอีก การทำลาย sender ทิ้งจะตัดการเชื่อมต่อของอินสแตนซ์ Worker ทั้งหมดและส่งสัญญาณบอกให้พวกมันปิดตัวลง โดย Worker แต่ละตัวจะพิมพ์ข้อความเมื่อถูกตัดการเชื่อมต่อ จากนั้นพูลเธรดจึงสั่งเรียก join เพื่อรอให้เธรดของ Worker แต่ละตัวทำงานเสร็จสิ้นลงอย่างสมบูรณ์
สังเกตแง่มุมที่น่าสนใจอย่างหนึ่งในรอบการทำงานนี้: ThreadPool ได้ทำลาย sender ทิ้งไปแล้ว และก่อนที่ Worker ตัวใดจะได้รับข้อผิดพลาด เราได้พยายาม join กับ Worker 0 ในขณะที่ Worker 0 ยังไม่ได้รับข้อผิดพลาดจากการเรียก recv เธรดหลักจึงหยุดรอ (block) จนกว่า Worker 0 จะทำงานเสร็จ ในระหว่างนั้น Worker 3 ได้รับงานไปทำ แล้วหลังจากนั้นเธรดทั้งหมดจึงได้รับข้อผิดพลาดจากแชนเนลที่ปิดลง และเมื่อ Worker 0 ทำงานเสร็จสิ้น เธรดหลักก็รอให้ Worker ที่เหลือทำงานจนเสร็จ ซึ่ง ณ จุดนั้นพวกมันทั้งหมดต่างออกจากลูปและปิดตัวลงเป็นที่เรียบร้อยแล้ว
ขอแสดงความยินดีด้วย! ตอนนี้เราได้สร้างโปรเจกต์ส่งท้ายนี้จนเสร็จสมบูรณ์แล้ว เรามีเว็บเซิร์ฟเวอร์ขั้นพื้นฐานที่นำพูลเธรดมาใช้ในการตอบสนองต่อคำขอแบบอะซิงโครนัสได้อย่างมีประสิทธิภาพ และเรายังสามารถสั่งปิดเซิร์ฟเวอร์ลงอย่างนุ่มนวลพร้อมทั้งเก็บกวาดทำความสะอาดเธรดทั้งหมดในพูลได้อย่างปลอดภัย
นี่คือโค้ดฉบับสมบูรณ์สำหรับใช้อ้างอิง:
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();
}
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 {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
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),
}
}
}
เรายังสามารถต่อยอดสิ่งต่าง ๆ ได้อีกมากจากจุดนี้! หากคุณต้องการพัฒนาและปรับปรุงโปรเจกต์นี้ต่อไป นี่คือไอเดียบางส่วนที่คุณสามารถลองทำได้:
- เพิ่มเอกสารประกอบ (documentation) ให้กับ
ThreadPoolและเมธอดสาธารณะต่าง ๆ ของมัน - เพิ่มแบบทดสอบอัตโนมัติ (tests) เพื่อตรวจสอบความถูกต้องในการทำงานของไลบรารี
- ปรับเปลี่ยนจากการเรียกใช้
unwrapไปเป็นการจัดการข้อผิดพลาดที่มีความแข็งแกร่งและปลอดภัยยิ่งขึ้น - นำ
ThreadPoolไปประยุกต์ใช้งานประมวลผลอื่น ๆ นอกเหนือจากการให้บริการคำขอของเว็บ - ค้นหาเครตสำหรับพูลเธรดบน crates.io แล้วลองสร้างเว็บเซิร์ฟเวอร์ที่คล้ายกันโดยใช้เครตดังกล่าว จากนั้นลองเปรียบเทียบรูปแบบของ API และความแข็งแกร่งในการทำงานกับพูลเธรดที่เราลงมือเขียนขึ้นเอง
สรุป
ยอดเยี่ยมมาก! คุณเดินทางมาถึงบทสุดท้ายของหนังสือเล่มนี้แล้ว! เราขอขอบคุณเป็นอย่างยิ่งที่คุณได้ร่วมเดินทางสำรวจโลกของภาษา Rust ไปพร้อมกับเรา ในตอนนี้คุณมีความรู้และเครื่องมือที่พร้อมสำหรับการสร้างสรรค์โปรเจกต์ Rust ของคุณเอง รวมถึงพร้อมที่จะเข้าไปมีส่วนร่วมและช่วยเหลือโปรเจกต์ของผู้อื่นในชุมชนแล้ว และโปรดจำไว้เสมอว่า มีชุมชนชาว Rustaceans ที่เป็นมิตรและพร้อมต้อนรับ คอยให้ความช่วยเหลือคุณในทุก ๆ ความท้าทายที่คุณจะได้พบเจอบนเส้นทางการเขียนโปรแกรมด้วยภาษา Rust!