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

จากเว็บเซิร์ฟเวอร์แบบเธรดเดียวสู่เว็บเซิร์ฟเวอร์แบบหลายเธรด

ในตอนนี้ เซิร์ฟเวอร์จะประมวลผลคำขอทีละรายการตามลำดับ หมายความว่าเซิร์ฟเวอร์จะไม่เริ่มประมวลผลการเชื่อมต่อที่สองจนกว่าการเชื่อมต่อแรกจะเสร็จสิ้น หากเซิร์ฟเวอร์ได้รับคำขอเข้ามาเป็นจำนวนมาก การทำงานตามลำดับเช่นนี้ (serial execution) จะยิ่งด้อยประสิทธิภาพลงเรื่อย ๆ ยิ่งถ้าเซิร์ฟเวอร์ได้รับคำขอที่ต้องใช้เวลาประมวลผลนาน คำขออื่น ๆ ที่ตามมาจะต้องรอคอยจนกว่าคำขอที่ใช้เวลานานนั้นจะเสร็จสิ้น แม้ว่าคำขอใหม่เหล่านั้นจะสามารถประมวลผลได้อย่างรวดเร็วก็ตาม เราจำเป็นต้องแก้ไขปัญหานี้ แต่ก่อนอื่น มาจำลองสถานการณ์จริงเพื่อดูปัญหานี้ให้เห็นภาพชัดเจนกันก่อน

การจำลองคำขอที่ช้า

เราจะมาดูกันว่าคำขอที่ประมวลผลช้าจะส่งผลกระทบต่อคำขออื่น ๆ ที่ส่งมายังเซิร์ฟเวอร์เวอร์ชันปัจจุบันของเราอย่างไร ลิสติ้ง 21-10 เพิ่มการจัดการคำขอที่เรียกมายัง /sleep โดยจำลองการตอบกลับที่ล่าช้าด้วยการสั่งให้เซิร์ฟเวอร์หยุดพักการทำงาน (sleep) เป็นเวลา 5 วินาทีก่อนจะส่งข้อมูลตอบกลับ

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 เนื่องจากตอนนี้เรามี 3 กรณีที่ต้องจัดการ และเราจำเป็นต้องจับคู่กับสไลซ์ (slice) ของ request_line อย่างชัดเจน เพื่อจับคู่แพตเทิร์นเข้ากับค่าสตริงลิเทอรัล (string literal) เพราะ match ไม่ได้ทำการอ้างอิงและดีเรเฟอเรนซ์ให้อัตโนมัติเหมือนกับการทำงานของเมธอดตรวจสอบความเท่ากัน

กิ่ง (arm) แรกทำงานเหมือนกับบล็อก if จากลิสติ้ง 21-9 ส่วนกิ่งที่สองจะจับคู่กับคำขอที่เรียกมายัง /sleep โดยเมื่อได้รับคำขอนี้ เซิร์ฟเวอร์จะหยุดพักการทำงานเป็นเวลา 5 วินาทีก่อนจะเรนเดอร์หน้า HTML แจ้งความสำเร็จ และกิ่งที่สามทำงานเหมือนกับบล็อก else จากลิสติ้ง 21-9

คุณจะเห็นได้ว่าเซิร์ฟเวอร์ของเรายังมีความเรียบง่ายและเป็นแบบดิบมาก ในขณะที่ไลบรารีของจริงจะจัดการการตรวจจับคำขอรูปแบบต่าง ๆ ด้วยวิธีที่กระชับและยืดหยุ่นกว่านี้มาก!

เริ่มรันเซิร์ฟเวอร์ด้วยคำสั่ง cargo run จากนั้นเปิดหน้าต่างเบราว์เซอร์ขึ้นมา 2 หน้าต่าง: หน้าต่างหนึ่งเปิด http://127.0.0.1:7878 และอีกหน้าต่างเปิด http://127.0.0.1:7878/sleep หากคุณเข้า URI / ซ้ำ ๆ หลายครั้งเหมือนก่อนหน้านี้ จะเห็นว่าเซิร์ฟเวอร์ตอบกลับอย่างรวดเร็ว แต่หากคุณเข้า /sleep แล้วรีเฟรชหน้า / ทันที คุณจะพบว่าหน้า / ต้องรอจนกว่าคำสั่ง sleep จะทำงานครบ 5 วินาทีเต็มเสียก่อนจึงจะเริ่มโหลดหน้าเว็บได้

มีหลากหลายเทคนิคที่เราสามารถนำมาใช้เพื่อป้องกันไม่ให้คำขอต่าง ๆ ต้องไปติดค้างอยู่เบื้องหลังคำขอที่ทำงานช้า รวมถึงการใช้ async ดังที่เราได้ศึกษาไปในบทที่ 17 แต่แนวทางที่เราจะเลือกสร้างขึ้นมาในบทนี้คือ พูลเธรด (thread pool)

การปรับปรุงทรูพุตด้วยพูลเธรด

พูลเธรด (thread pool) คือกลุ่มของเธรดที่ถูกสร้างขึ้นเตรียมพร้อมไว้ล่วงหน้าเพื่อรอรับงาน เมื่อโปรแกรมได้รับงานใหม่ โปรแกรมจะมอบหมายงานนั้นให้แก่เธรดตัวใดตัวหนึ่งในพูล และเธรดนั้นจะรับหน้าที่ประมวลผลงานดังกล่าว ส่วนเธรดที่เหลือในพูลก็ยังพร้อมรองรับงานอื่น ๆ ที่อาจทยอยเข้ามาในระหว่างที่เธรดแรกกำลังทำงานอยู่ เมื่อเธรดแรกประมวลผลงานของตนเสร็จสิ้น ก็จะกลับคืนสู่พูลในสถานะว่าง เพื่อรอรับงานใหม่ต่อไป การใช้พูลเธรดจึงช่วยให้คุณประมวลผลการเชื่อมต่อหลายรายการพร้อมกันได้ ซึ่งช่วยเพิ่มขีดความสามารถในการรองรับงาน (throughput) ของเซิร์ฟเวอร์ได้อย่างมาก

เราจะจำกัดจำนวนเธรดในพูลไว้ในปริมาณไม่มากนักเพื่อช่วยป้องกันการโจมตีแบบปฏิเสธการให้บริการ (Denial of Service หรือ DoS) เพราะหากเราปล่อยให้โปรแกรมสร้างเธรดใหม่สำหรับทุกคำขอที่ส่งเข้ามา หากมีผู้ไม่ประสงค์ดีส่งคำขอเข้ามา 10 ล้านครั้งพร้อมกัน ก็อาจสร้างความเสียหายร้ายแรงด้วยการผลาญทรัพยากรทั้งหมดของระบบจนหมดสิ้น และทำให้เซิร์ฟเวอร์หยุดทำงานจนไม่สามารถประมวลผลคำขอใด ๆ ได้อีกเลย

ดังนั้น แทนที่จะสร้างเธรดอย่างไร้ขีดจำกัด เราจะมีเธรดตามจำนวนที่กำหนดคงที่รอคอยอยู่ในพูล คำขอใหม่ที่เข้ามาจะถูกส่งตรงไปยังพูลเพื่อประมวลผล โดยพูลจะคอยดูแลคิวของคำขอที่เข้ามา เธรดแต่ละตัวในพูลจะคอยดึงคำขอออกจากคิวนี้ไปจัดการ แล้ววนกลับมาขอดึงคำขอถัดไปจากคิวเรื่อย ๆ ด้วยสถาปัตยกรรมเช่นนี้ เราจึงสามารถประมวลผลคำขอได้พร้อมกันสูงสุดถึง N คำขอ โดยที่ N คือจำนวนเธรด แม้ว่าหากทุกเธรดกำลังติดพันกับคำขอที่ใช้เวลานาน คำขอใหม่ที่เข้ามาก็ยังอาจต้องรออยู่ในคิวเช่นเดิม แต่วิธีนี้ช่วยเพิ่มขีดความสามารถในการรองรับคำขอที่ใช้เวลานานได้มากขึ้นอย่างมีนัยสำคัญก่อนที่จะถึงจุดคอขวด

เทคนิคนี้เป็นเพียงหนึ่งในหลากหลายวิธีสำหรับการเพิ่มทรูพุตของเว็บเซิร์ฟเวอร์ ทางเลือกอื่น ๆ ที่คุณอาจศึกษาเพิ่มเติมได้แก่ โมเดลแบบ fork/join, โมเดลแบบ single-threaded async I/O และโมเดลแบบ multithreaded async I/O หากคุณสนใจในหัวข้อนี้ คุณสามารถค้นคว้าแนวทางอื่น ๆ เพิ่มเติมและทดลองสร้างขึ้นมาได้จริง เพราะด้วยภาษาที่ทำงานในระดับล่างอย่าง Rust ทางเลือกทั้งหมดเหล่านี้ล้วนสามารถทำได้ทั้งสิ้น

ก่อนที่เราจะลงมือสร้างพูลเธรด มาลองพูดคุยกันก่อนว่าการเรียกใช้งานพูลนี้ควรมีหน้าตาอย่างไร เมื่อคุณกำลังออกแบบโค้ด การเขียนอินเทอร์เฟซในมุมของผู้เรียกใช้งาน (client interface) ไว้ล่วงหน้าจะช่วยชี้นำทิศทางการออกแบบได้เป็นอย่างดี โดยให้เขียน API ของโค้ดตามโครงสร้างที่คุณต้องการเรียกใช้จริงก่อน จากนั้นจึงค่อยลงมือสร้างฟังก์ชันการทำงานจริงตามโครงสร้างนั้น แทนที่จะเขียนฟังก์ชันการทำงานจนเสร็จแล้วค่อยมาออกแบบ API สาธารณะในภายหลัง

คล้ายกับที่เราเคยใช้การพัฒนาที่ขับเคลื่อนด้วยการทดสอบ (test-driven development หรือ TDD) ในโปรเจกต์ของบทที่ 12 ในบทนี้เราจะใช้การพัฒนาที่ขับเคลื่อนด้วยคอมไพเลอร์ (compiler-driven development) กล่าวคือ เราจะเขียนโค้ดเรียกใช้ฟังก์ชันตามที่เราต้องการก่อน แล้วอาศัยข้อความแจ้งเตือนข้อผิดพลาดจากคอมไพเลอร์เป็นตัวนำทางว่าเราต้องแก้ไขจุดใดต่อไปเพื่อให้โปรแกรมทำงานได้ อย่างไรก็ดี ก่อนจะไปถึงจุดนั้น เรามาลองสำรวจเทคนิคที่ ไม่แนะนำ ให้ใช้ เพื่อเป็นจุดเริ่มต้นในการเปรียบเทียบกันก่อน

การสร้างเธรดใหม่สำหรับแต่ละคำขอ

ก่อนอื่น มาดูว่าโค้ดของเราจะมีหน้าตาอย่างไรหากสั่งสร้างเธรดใหม่ขึ้นมาสำหรับทุก ๆ การเชื่อมต่อจริง ๆ อย่างที่ได้กล่าวไปแล้วว่านี่ไม่ใช่แผนสุดท้ายที่เราจะใช้ เนื่องจากอาจเกิดปัญหาจากการสร้างเธรดได้ไม่จำกัด แต่นี่เป็นจุดเริ่มต้นที่ดีในการทำความเข้าใจการทำงานของเว็บเซิร์ฟเวอร์แบบหลายเธรด จากนั้นเมื่อเรานำพูลเธรดเข้ามาปรับปรุง จะช่วยให้เห็นความแตกต่างของทั้งสองวิธีได้อย่างชัดเจน

ลิสติ้ง 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 จะสร้างเธรดใหม่ขึ้นมาและรันโค้ดในโคลเชอร์ (closure) บนเธรดใหม่นั้น หากคุณรันโค้ดนี้แล้วเปิดหน้า /sleep บนเบราว์เซอร์ จากนั้นเปิดหน้า / ในแท็บอื่น ๆ คุณจะพบว่าคำขอที่เรียกไปยัง / ไม่จำเป็นต้องรอให้หน้า /sleep ทำงานเสร็จอีกต่อไป อย่างไรก็ดี ตามที่เราได้เตือนไว้ วิธีนี้จะทำให้ระบบทำงานหนักเกินพิกัดในที่สุด เพราะเซิร์ฟเวอร์จะสร้างเธรดใหม่ขึ้นมาเรื่อย ๆ อย่างไร้ขีดจำกัด

คุณอาจจำได้จากบทที่ 17 ว่าสถานการณ์เช่นนี้คือจุดที่ async และ await โดดเด่นอย่างแท้จริง! ขอให้จำจุดนี้ไว้ในใจขณะที่เรากำลังสร้างพูลเธรด และลองขบคิดดูว่าหากเปลี่ยนมาใช้ async โค้ดของเราจะมีความเหมือนหรือแตกต่างจากเดิมอย่างไรบ้าง

การสร้างเธรดจำนวนจำกัด

เราต้องการให้พูลเธรดมีรูปแบบการเรียกใช้งานที่คล้ายคลึงและคุ้นเคย เพื่อให้การเปลี่ยนจากการสร้างเธรดโดยตรงมาใช้พูลเธรดแทบไม่ต้องแก้ไขโค้ดส่วนที่เรียกใช้ API เดิมเลย ลิสติ้ง 21-12 แสดงอินเทอร์เฟซในอุดมคติของ struct 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::new เพื่อสร้างพูลเธรดใหม่ที่มีจำนวนเธรดตามที่กำหนด ซึ่งในที่นี้คือ 4 เธรด จากนั้นในลูป for เมธอด pool.execute จะมีรูปแบบอินเทอร์เฟซคล้ายกับ thread::spawn โดยรับโคลเชอร์ที่พูลควรรันสำหรับแต่ละสตรีม เราจำเป็นต้องสร้างเมธอด pool.execute ให้สามารถรับโคลเชอร์แล้วส่งมอบให้แก่เธรดว่างในพูลเพื่อนำไปรัน แน่นอนว่าโค้ดนี้ยังคอมไพล์ไม่ผ่าน แต่เราจะลองคอมไพล์ดูเพื่อให้ข้อความจากคอมไพเลอร์ช่วยนำทางเราในการแก้ไขต่อไป

การสร้าง ThreadPool ด้วยการพัฒนาแบบขับเคลื่อนด้วยคอมไพเลอร์

ให้แก้ไขโค้ดใน src/main.rs ตามลิสติ้ง 21-12 จากนั้นเราจะใช้ข้อความแจ้งเตือนข้อผิดพลาดจากคำสั่ง 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

ยอดเยี่ยม! ข้อผิดพลาดนี้บอกให้เรารู้ว่าโปรแกรมยังขาดชนิดข้อมูลหรือมอดูล (module) ThreadPool เราจึงจะสร้างมันขึ้นมาในตอนนี้ และเนื่องจากโครงสร้างการทำงานของ ThreadPool ควรเป็นอิสระจากลักษณะงานเฉพาะของเว็บเซิร์ฟเวอร์ เราจึงจะปรับเปลี่ยนโครงสร้างของเครต (crate) hello จากเดิมที่เป็นเครตไบนารี (binary crate) ให้กลายเป็นเครตไลบรารี (library crate) เพื่อใช้เก็บโค้ดการทำงานของ ThreadPool โดยเฉพาะ ซึ่งการแยกเป็นเครตไลบรารีเช่นนี้จะทำให้เราสามารถนำไลบรารีพูลเธรดนี้ไปประยุกต์ใช้กับงานอื่น ๆ ที่ต้องการใช้พูลเธรดได้ด้วย ไม่จำกัดเพียงแค่งานให้บริการคำขอเว็บเท่านั้น

สร้างไฟล์ src/lib.rs โดยใส่โค้ดต่อไปนี้ ซึ่งเป็นนิยามที่เรียบง่ายที่สุดของ struct 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 อีกครั้งเพื่อดูข้อผิดพลาดถัดไปที่เราต้องลงมือจัดการ:

$ 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

ข้อผิดพลาดนี้ชี้ให้เห็นว่าในขั้นตอนต่อไป เราต้องสร้างฟังก์ชันที่มีความสัมพันธ์กับชนิดข้อมูล (associated function) ชื่อ 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 เราสามารถรับโคลเชอร์เป็นพารามิเตอร์ผ่านเทรต 3 ตัวที่แตกต่างกัน ได้แก่ Fn, FnMut และ FnOnce เราจึงต้องตัดสินใจว่าจะใช้โคลเชอร์ชนิดใดในจุดนี้ เรารู้ว่าในท้ายที่สุดการทำงานของเราจะคล้ายคลึงกับการทำงานของ thread::spawn ในไลบรารีมาตรฐาน ดังนั้นเราจึงสามารถเข้าไปดูข้อกำหนด (bounds) บนพารามิเตอร์ในซิกเนเจอร์ของ thread::spawn ได้ ซึ่งเอกสารแสดงให้เห็นดังนี้:

pub fn spawn<F, T>(f: F) -> JoinHandle<T>
    where
        F: FnOnce() -> T,
        F: Send + 'static,
        T: Send + 'static,

พารามิเตอร์ชนิดข้อมูล (type parameter) F คือสิ่งที่เราให้ความสนใจในที่นี้ ส่วนพารามิเตอร์ชนิดข้อมูล T นั้นเกี่ยวข้องกับค่าที่คืนกลับ ซึ่งเราไม่จำเป็นต้องสนใจ เราจะเห็นว่า spawn กำหนดข้อกำหนดเทรต (trait bound) บน F ไว้เป็น FnOnce ซึ่งเป็นสิ่งที่เราต้องการเช่นเดียวกัน เพราะในท้ายที่สุดเราจะส่งอาร์กิวเมนต์ที่ได้รับใน execute ส่งต่อไปให้ spawn และเรายิ่งมั่นใจได้ว่า FnOnce คือเทรตที่ถูกต้อง เนื่องจากเธรดที่ทำหน้าที่ประมวลผลคำขอจะรันโคลเชอร์ของคำขอนั้นเพียงครั้งเดียวเท่านั้น ซึ่งสอดคล้องกับคำว่า Once ใน FnOnce

นอกจากนี้ พารามิเตอร์ชนิดข้อมูล F ยังมีข้อกำหนดเทรต Send และข้อกำหนดช่วงอายุ (lifetime bound) '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 เพราะในที่นี้แทนโคลเชอร์ที่ไม่รับพารามิเตอร์ใด ๆ และคืนค่าเป็นชนิดยูนิต () เช่นเดียวกับนิยามฟังก์ชันทั่วไป ชนิดข้อมูลของค่าที่คืนกลับสามารถละเว้นได้ในซิกเนเจอร์ แต่ถึงแม้จะไม่มีพารามิเตอร์ เราก็ยังคงต้องใส่วงเล็บไว้เสมอ

เช่นเคย นี่คือการเขียนเมธอด 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 ว่า “ถ้าโค้ดคอมไพล์ผ่าน แสดงว่าโค้ดทำงานได้ถูกต้อง” แต่นั่นไม่ได้เป็นจริงเสมอไป ในตอนนี้โปรเจกต์ของเราคอมไพล์ผ่านได้อย่างราบรื่น แต่มันยังไม่ได้ทำสิ่งใดเลย! หากนี่เป็นการพัฒนาโปรเจกต์จริงที่สมบูรณ์ นี่คือ จังหวะที่เหมาะสมอย่างยิ่งในการเริ่มเขียนแบบทดสอบระดับยูนิต (unit test) เพื่อ ยืนยันว่าโค้ดคอมไพล์ผ่าน และ ทำงานได้ถูกต้องตามที่เราคาดหวังจริง ๆ

ลองขบคิดดู: หากในจุดนี้เราต้องการรันฟิวเจอร์ (future) แทนที่จะเป็นโคลเชอร์ โค้ดจะมีความแตกต่างไปอย่างไรบ้าง?

การตรวจสอบความถูกต้องของจำนวนเธรดใน new

เรายังไม่ได้ทำอะไรกับพารามิเตอร์ของ new และ execute เลย มาเริ่มเขียนเนื้อหาภายในฟังก์ชันเหล่านี้ให้มีพฤติกรรมการทำงานตามที่เราต้องการกัน เริ่มจากฟังก์ชัน new ก่อนหน้านี้เราเลือกชนิดข้อมูลแบบไม่มีเครื่องหมายให้กับพารามิเตอร์ size เพราะพูลที่มีจำนวนเธรดติดลบนั้นเป็นไปไม่ได้ในทางปฏิบัติ อย่างไรก็ดี พูลที่มีจำนวนเธรดเป็นศูนย์ก็ไม่สมเหตุสมผลเช่นกัน แม้ว่าศูนย์จะเป็นค่าที่ถูกต้องตามชนิดข้อมูล usize ก็ตาม ดังนั้นเราจะเพิ่มโค้ดตรวจสอบว่า size มีค่ามากกว่าศูนย์ก่อนจะคืนค่าอินสแตนซ์ของ ThreadPool ออกไป และกำหนดให้โปรแกรมแพนิก (panic) ทันทีหากได้รับค่าเป็นศูนย์ โดยใช้มาโคร assert! ดังแสดงในลิสติ้ง 21-13

pub struct ThreadPool;

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);

        ThreadPool
    }

    // --snip--
    pub fn execute<F>(&self, f: F)
    where
        F: FnOnce() + Send + 'static,
    {
    }
}

เรายังได้เพิ่มเอกสารประกอบให้กับ ThreadPool ผ่านทางคอมเมนต์เอกสาร (doc comment) สังเกตว่าเราได้ปฏิบัติตามแนวทางที่ดีในการเขียนเอกสารประกอบ โดยเพิ่มหัวข้อย่อยระบุเงื่อนไขที่ฟังก์ชันของเราอาจเกิดการแพนิกได้ ดังที่เราได้เรียนรู้ในบทที่ 14 ลองรันคำสั่ง cargo doc --open แล้วคลิกดูที่ struct ThreadPool เพื่อดูเอกสารที่สร้างขึ้นสำหรับฟังก์ชัน new กันได้เลย!

แทนที่จะใช้มาโคร assert! เช่นนี้ เราอาจเปลี่ยนฟังก์ชัน new ไปเป็น build แล้วคืนค่าเป็น Result เหมือนที่เราเคยทำกับ Config::build ในโปรเจกต์ I/O ในลิสติ้ง 12-9 ได้ แต่ในกรณีนี้เราตัดสินใจว่าการพยายามสร้างพูลเธรดที่ไม่มีเธรดอยู่เลยถือเป็นข้อผิดพลาดที่ไม่สามารถกู้คืนได้ (unrecoverable error) หากคุณต้องการความท้าทายเพิ่มเติม ลองเขียนฟังก์ชันชื่อ build ที่มีซิกเนเจอร์ดังต่อไปนี้เพื่อเปรียบเทียบกับฟังก์ชัน new ดูได้:

pub fn build(size: usize) -> Result<ThreadPool, PoolCreationError> {

การสร้างพื้นที่สำหรับจัดเก็บเธรด

เมื่อเรามีวิธีตรวจสอบแล้วว่าจำนวนเธรดที่กำหนดให้จัดเก็บในพูลมีความถูกต้อง เราก็สามารถสร้างเธรดเหล่านั้นขึ้นมาและจัดเก็บไว้ใน struct ThreadPool ก่อนจะคืนค่า struct ออกไปได้ แต่คำถามคือเราจะ “จัดเก็บ” เธรดไว้ได้อย่างไร? มาดูซิกเนเจอร์ของ 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--
    /// 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 mut threads = Vec::with_capacity(size);

        for _ in 0..size {
            // create some threads and store them in the vector
        }

        ThreadPool { threads }
    }
    // --snip--

    pub fn execute<F>(&self, f: F)
    where
        F: FnOnce() + Send + 'static,
    {
    }
}

เรานำ std::thread เข้ามาสู่ขอบเขตการทำงานในเครตไลบรารี เนื่องจากเราใช้ thread::JoinHandle เป็นชนิดข้อมูลของสมาชิกในเวกเตอร์ของ ThreadPool

เมื่อได้ค่าขนาดที่ถูกต้อง ThreadPool จะสร้างเวกเตอร์ใหม่ที่สามารถรองรับสมาชิกได้ size ตัว ฟังก์ชัน Vec::with_capacity ทำงานคล้ายกับ Vec::new แต่มีข้อแตกต่างที่สำคัญคือ มีการจัดสรรหน่วยความจำล่วงหน้าสำหรับเวกเตอร์ และเนื่องจากเรารู้จำนวนสมาชิก size ตัวที่แน่นอนที่จะจัดเก็บ การจัดสรรล่วงหน้าเช่นนี้จึงมีประสิทธิภาพสูงกว่าการใช้ Vec::new เล็กน้อย ซึ่งจะต้องคอยขยายขนาดหน่วยความจำทุกครั้งที่มีการแทรกสมาชิกใหม่

เมื่อคุณรันคำสั่ง cargo check อีกครั้ง การตรวจสอบควรผ่านฉลุย

การส่งโค้ดจาก ThreadPool ไปยังเธรด

เราได้ใส่คอมเมนต์ทิ้งไว้ในลูป for ของลิสติ้ง 21-14 เกี่ยวกับการสร้างเธรด ตรงนี้เราจะมาดูกันว่าเราจะสร้างเธรดขึ้นมาจริง ๆ ได้อย่างไร ไลบรารีมาตรฐานมี thread::spawn สำหรับสร้างเธรด ซึ่งฟังก์ชันนี้คาดหวังว่าจะได้รับโค้ดที่เธรดต้องรันทันทีที่ถูกสร้างขึ้น ทว่าในกรณีของเรา เราต้องการสร้างเธรดเตรียมไว้ล่วงหน้าแล้วให้พวกมัน รอรับ โค้ดที่เราจะส่งไปให้ในภายหลัง ซึ่งโครงสร้างเธรดของไลบรารีมาตรฐานไม่ได้มีกลไกนี้มาให้ในตัว เราจึงจำเป็นต้องสร้างกลไกนี้ขึ้นมาเอง

เราจะสร้างโครงสร้างข้อมูลใหม่คั่นกลางระหว่าง ThreadPool กับเธรด เพื่อทำหน้าที่จัดการพฤติกรรมดังกล่าว โดยเราจะตั้งชื่อโครงสร้างข้อมูลนี้ว่า Worker ซึ่งเป็นคำศัพท์มาตรฐานที่ใช้กันทั่วไปในการสร้างระบบพูล โครงสร้าง Worker จะมีหน้าที่รับโค้ดที่ต้องทำงานแล้วนำไปรันบนเธรดของมันเอง

ลองนึกภาพพนักงานในครัวของร้านอาหาร: พนักงาน (worker) จะคอยรอจนกว่าจะมีรายการสั่งอาหารเข้ามาจากลูกค้า จากนั้นจึงรับรายการอาหารนั้นไปปรุงให้เสร็จสิ้น

แทนที่จะจัดเก็บเวกเตอร์ของ JoinHandle<()> ในพูลเธรด เราจะเปลี่ยนมาจัดเก็บอินสแตนซ์ของ struct Worker แทน โดย Worker แต่ละตัวจะเก็บอินสแตนซ์ JoinHandle<()> ไว้หนึ่งตัว จากนั้นเราจะสร้างเมธอดบน Worker ที่รับโคลเชอร์ของโค้ดที่ต้องรัน แล้วส่งต่อไปยังเธรดที่กำลังทำงานอยู่เพื่อเริ่มประมวลผล นอกจากนี้เรายังจะกำหนดค่า id ให้กับ Worker แต่ละตัว เพื่อให้สามารถแยกแยะอินสแตนซ์ของ Worker แต่ละตัวในพูลได้อย่างชัดเจนเวลาพิมพ์ล็อกหรือดีบัก

นี่คือขั้นตอนการทำงานใหม่ที่จะเกิดขึ้นเมื่อเราสร้าง ThreadPool โดยเราจะเขียนโค้ดสำหรับส่งโคลเชอร์ไปยังเธรดหลังจากที่เราตั้งค่าโครงสร้าง Worker เสร็จเรียบร้อย:

  1. นิยาม struct Worker ที่เก็บ id และ JoinHandle<()>
  2. ปรับเปลี่ยน ThreadPool ให้เก็บเวกเตอร์ของอินสแตนซ์ Worker
  3. นิยามฟังก์ชัน Worker::new ที่รับค่าหมายเลข id และคืนค่าอินสแตนซ์ Worker ที่เก็บ id และเธรดที่สร้างขึ้นด้วยโคลเชอร์ว่างเปล่า
  4. ใน ThreadPool::new ให้นำตัวนับของลูป for มากำหนดเป็น id สร้าง Worker ใหม่ด้วย id นั้น แล้วจัดเก็บ Worker ลงในเวกเตอร์

หากคุณพร้อมสำหรับความท้าทาย ลองลงมือแก้ไขโค้ดตามขั้นตอนเหล่านี้ด้วยตัวเองก่อนจะดูเฉลยในลิสติ้ง 21-15

พร้อมหรือยัง? ด้านล่างนี้คือลิสติ้ง 21-15 ซึ่งแสดงตัวอย่างการปรับปรุงโค้ดตามแนวทางข้างต้น

use std::thread;

pub struct ThreadPool {
    workers: Vec<Worker>,
}

impl ThreadPool {
    // --snip--
    /// 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 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 จาก threads เป็น workers เพราะตอนนี้มันเก็บอินสแตนซ์ของ Worker แทนที่จะเป็น JoinHandle<()> โดยตรง เราส่งตัวนับในลูป for ไปเป็นอาร์กิวเมนต์ของ Worker::new และจัดเก็บแต่ละ Worker ที่สร้างขึ้นใหม่ลงในเวกเตอร์ workers

โค้ดส่วนอื่นภายนอก (เช่น เซิร์ฟเวอร์ใน src/main.rs) ไม่จำเป็นต้องรับรู้รายละเอียดเชิงลึกว่าภายใน ThreadPool มีการใช้ struct Worker อย่างไร เราจึงกำหนดให้ struct Worker และฟังก์ชัน new ของมันเป็นแบบส่วนตัว (private) ฟังก์ชัน Worker::new จะนำ id ที่ส่งเข้ามาไปจัดเก็บคู่กับอินสแตนซ์ JoinHandle<()> ที่ได้จากการสร้างเธรดใหม่ด้วยโคลเชอร์ว่างเปล่า

หมายเหตุ: หากระบบปฏิบัติการไม่สามารถสร้างเธรดได้เนื่องจากทรัพยากรระบบไม่ เพียงพอ ฟังก์ชัน thread::spawn จะเกิดการแพนิก ซึ่งส่งผลให้เซิร์ฟเวอร์ ทั้งหมดแพนิกและหยุดทำงานไปด้วย แม้ว่าเธรดก่อนหน้านั้นบางตัวจะสร้างสำเร็จแล้ว ก็ตาม สำหรับการเรียนรู้นี้ พฤติกรรมดังกล่าวถือว่าเพียงพอแล้ว แต่ในการสร้าง พูลเธรดระดับโปรดักชันจริง คุณควรใช้ std::thread::Builder ร่วมกับเมธอด spawn ที่คืนค่าเป็น Result แทน

โค้ดชุดนี้จะคอมไพล์ผ่านและจัดเก็บอินสแตนซ์ Worker ตามจำนวนที่เราระบุเป็นอาร์กิวเมนต์ใน ThreadPool::new ได้เรียบร้อย แต่เรา ยังไม่ได้ นำโคลเชอร์ที่ส่งเข้ามาใน execute ไปประมวลผลจริง ในหัวข้อถัดไปเรามาดูวิธีทำสิ่งนั้นกัน

การส่งคำขอไปยังเธรดผ่านแชนเนล

ปัญหาถัดไปที่เราต้องจัดการคือ โคลเชอร์ที่ส่งให้กับ thread::spawn ยังไม่ได้ทำสิ่งใดเลย ในปัจจุบัน เราได้รับโคลเชอร์ที่ต้องการรันเข้ามาทางเมธอด execute แต่เราจำเป็นต้องส่งโคลเชอร์ให้ thread::spawn ไปตั้งแต่ตอนสร้าง Worker แต่ละตัวระหว่างการเริ่มต้น ThreadPool

สิ่งที่เราต้องการคือ ให้ struct Worker ที่เพิ่งสร้างขึ้นไปคอยดึงโค้ดที่ต้องรันมาจากคิวที่เก็บอยู่ใน ThreadPool แล้วส่งโค้ดดังกล่าวไปยังเธรดของตัวเองเพื่อเริ่มทำงาน

แชนเนล (channel) ที่เราได้เรียนรู้ในบทที่ 16 ซึ่งเป็นวิธีที่สะดวกและง่ายดายในการสื่อสารระหว่างเธรด จึงตอบโจทย์การใช้งานนี้ได้อย่างลงตัว เราจะใช้แชนเนลทำหน้าที่เป็นคิวของงาน (job) โดยเมธอด execute จะส่งงานจาก ThreadPool ไปยังอินสแตนซ์ของ Worker ซึ่งจะส่งต่องานนั้นไปยังเธรดของตัวเองอีกทอดหนึ่ง นี่คือแผนการทำงานของเรา:

  1. ThreadPool จะสร้างแชนเนลขึ้นมาและเก็บฝั่งส่ง (sender) เอาไว้
  2. Worker แต่ละตัวจะถือครองฝั่งรับ (receiver) เอาไว้
  3. เราจะสร้าง struct Job ขึ้นมาใหม่เพื่อบรรจุโคลเชอร์ที่เราต้องการส่งผ่านแชนเนล
  4. เมธอด execute จะส่งงานที่ต้องการรันผ่านทางฝั่งส่ง
  5. ภายในเธรดของตัวเอง Worker จะวนลูปคอยรับข้อมูลจากฝั่งรับ แล้วสั่งรันโคลเชอร์ของงานใด ๆ ก็ตามที่ได้รับเข้ามา

มาเริ่มด้วยการสร้างแชนเนลใน ThreadPool::new และเก็บฝั่งส่งไว้ในอินสแตนซ์ของ ThreadPool ดังแสดงในลิสติ้ง 21-16 ในตอนนี้ struct Job ยังไม่ได้เก็บข้อมูลใด ๆ แต่จะกลายมาเป็นชนิดข้อมูลของสมาชิกที่เราส่งผ่านแชนเนลต่อไป

use std::{sync::mpsc, thread};

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

struct Job;

impl ThreadPool {
    // --snip--
    /// 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 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::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--
    /// 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 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::new แล้วเรียกใช้มันภายในโคลเชอร์

เมื่อเราลองตรวจสอบโค้ดนี้ด้วย cargo check ก็จะพบกับข้อผิดพลาดต่อไปนี้:

$ 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 หรือ mpsc) นั่นหมายความว่าเราไม่สามารถโคลนฝั่งรับ (consumer) ของแชนเนลเพื่อแก้ปัญหานี้ได้ และเราก็ไม่ได้ต้องการส่งข้อความซ้ำไปยังผู้รับหลายคนด้วย สิ่งที่เราต้องการคือคิวข้อความชุดเดียวที่แชร์ให้อินสแตนซ์ของ Worker หลายตัวเข้ามาดึงไป โดยแต่ละข้อความจะถูกประมวลผลเพียงครั้งเดียวเท่านั้น

นอกจากนี้ การดึงงานออกจากคิวของแชนเนลจำเป็นต้องเปลี่ยนแปลงค่า (mutate) ของ receiver เธรดต่าง ๆ จึงต้องการกลไกที่ปลอดภัยในการร่วมกันใช้งานและเปลี่ยนแปลงค่า receiver มิเช่นนั้นเราอาจพบกับสภาวะการแย่งชิงข้อมูล (race condition) ดังที่ได้อธิบายไว้ในบทที่ 16

ย้อนนึกถึงสมาร์ตพอยน์เตอร์ (smart pointer) ที่ปลอดภัยสำหรับการทำงานข้ามเธรดที่เราได้ศึกษาในบทที่ 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--
    /// 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 }
    }

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

ใน ThreadPool::new เราห่อหุ้มฝั่งรับไว้ภายใน Arc และ Mutex และสำหรับ Worker แต่ละตัวที่สร้างขึ้นใหม่ เราจะโคลน Arc เพื่อเพิ่มจำนวนการอ้างอิง (reference count) ทำให้อินสแตนซ์ของ Worker สามารถแชร์สิทธิ์ความเป็นเจ้าของฝั่งรับร่วมกันได้

หลังจากการปรับปรุงนี้ โค้ดก็คอมไพล์ผ่านฉลุย! เราเข้าใกล้เป้าหมายแล้ว!

การอิมพลีเมนต์เมธอด execute

ในที่สุดก็ถึงเวลาสร้างเมธอด execute บน ThreadPool แล้ว โดยเราจะเปลี่ยน Job จากเดิมที่เป็น struct ให้กลายเป็นนามแฝงชนิดข้อมูล (type alias) สำหรับเทรตออบเจกต์ (trait object) ที่บรรจุชนิดของโคลเชอร์ที่ส่งเข้ามายัง 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--
    /// 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();
    }
}

// --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 ใหม่โดยนำโคลเชอร์ที่ได้รับใน execute มาบรรจุไว้ เราก็ส่งงานนั้นผ่านทางฝั่งส่งของแชนเนล เราใช้ unwrap กับผลลัพธ์ของ send เผื่อกรณีที่การส่งล้มเหลว ซึ่งอาจเกิดขึ้นได้เช่น เมื่อเราสั่งหยุดการทำงานของเธรดทั้งหมด ทำให้ฝั่งรับปิดตัวลงและไม่รับข้อความใหม่อีกต่อไป แต่ในตอนนี้เรายังไม่มีคำสั่งหยุดเธรด เธรดของเราจึงจะรันอยู่ตลอดตราบเท่าที่พูลยังคงอยู่ สาเหตุที่เราใช้ unwrap ก็เพราะเรารู้ดีว่าข้อผิดพลาดนี้จะไม่เกิดขึ้นในตอนนี้ แม้ว่าคอมไพเลอร์จะไม่อาจล่วงรู้ได้ก็ตาม

แต่เรายังทำไม่เสร็จสมบูรณ์! เพราะใน Worker โคลเชอร์ที่ส่งให้ thread::spawn ยังเพียงแค่ อ้างถึง ฝั่งรับของแชนเนลเท่านั้น แต่สิ่งที่เราต้องการจริง ๆ คือให้โคลเชอร์วนลูปทำงานไปเรื่อย ๆ โดยคอยดึงงานจากฝั่งรับของแชนเนลและนำมาสั่งรันเมื่อได้รับงาน มาปรับแก้โค้ดใน Worker::new ตามที่แสดงในลิสติ้ง 21-20 กัน

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();
    }
}

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

ในจุดนี้ เราเรียกเมธอด lock บน receiver ก่อนเพื่อครอบครองล็อกของมิวเท็กซ์ จากนั้นจึงเรียก unwrap เพื่อให้เกิดการแพนิกหากพบข้อผิดพลาด การขอครอบครองล็อกอาจล้มเหลวได้หากมิวเท็กซ์ตกอยู่ในสถานะ ถูกวางยาพิษ (poisoned) ซึ่งเกิดขึ้นเมื่อเธรดอื่นเกิดการแพนิกในขณะที่ยังถือครองล็อกอยู่แทนที่จะปล่อยล็อกคืน ในสถานการณ์เช่นนี้ การเรียก unwrap เพื่อให้เธรดนี้หยุดทำงานด้วยการแพนิกตามไปด้วยถือเป็นแนวทางที่เหมาะสม หรือคุณอาจเลือกเปลี่ยน unwrap นี้เป็น expect พร้อมข้อความแจ้งเตือนข้อผิดพลาดที่สื่อความหมายชัดเจนตามต้องการก็ได้

เมื่อครอบครองล็อกของมิวเท็กซ์ได้แล้ว เราจะเรียกใช้ recv เพื่อรับ Job มาจากแชนเนล คำสั่ง unwrap ตัวสุดท้ายก็ทำหน้าที่จัดการข้อผิดพลาด ณ จุดนี้เช่นกัน ซึ่งอาจเกิดขึ้นได้หากเธรดที่เป็นฝั่งส่งปิดตัวลง คล้ายคลึงกับกรณีที่เมธอด send จะคืนค่า Err หากฝั่งรับปิดตัวลง

การเรียกใช้ recv จะทำการหยุดรอ (block) ดังนั้นหากยังไม่มีงานส่งเข้ามา เธรดปัจจุบันจะหยุดรอจนกว่าจะมีงานใหม่พร้อมให้ประมวลผล และ 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.

สำเร็จ! ตอนนี้เราได้พูลเธรดที่ประมวลผลการเชื่อมต่อแบบอะซิงโครนัส (asynchronous) เป็นที่เรียบร้อยแล้ว และจะไม่มีการสร้างเธรดเกิน 4 ตัวอย่างแน่นอน ระบบของเราจึงไม่ทำงานหนักจนเกินพิกัดเมื่อเซิร์ฟเวอร์ได้รับคำขอเข้ามาเป็นจำนวนมาก หากเราส่งคำขอไปยัง /sleep เซิร์ฟเวอร์ก็ยังคงสามารถให้บริการคำขออื่น ๆ ได้อย่างต่อเนื่องโดยให้เธรดตัวอื่นที่ว่างอยู่รับไปประมวลผลแทน

หมายเหตุ: หากคุณเปิดหน้า /sleep บนหน้าต่างเบราว์เซอร์หลายหน้าต่างพร้อมกัน หน้าเว็บอาจทยอยโหลดเสร็จทีละหน้าต่างโดยห่างกันช่วงละ 5 วินาที เนื่องจากเบราว์เซอร์ บางตัวจะประมวลผลคำขอที่ซ้ำกันตามลำดับทีละคำขอเพื่อการจัดการแคช (cache) ข้อจำกัดนี้จึงเกิดจากพฤติกรรมของเบราว์เซอร์ ไม่ใช่ข้อผิดพลาดของเว็บเซิร์ฟเวอร์เรา

นี่คือช่วงเวลาที่ดีในการหยุดพักและลองพิจารณาดูว่า โค้ดในลิสติ้ง 21-18, 21-19 และ 21-20 จะแตกต่างไปอย่างไรหากเราเปลี่ยนมาใช้ฟิวเจอร์ (futures) แทนโคลเชอร์สำหรับงานที่ต้องทำ ชนิดข้อมูลใดบ้างที่ต้องเปลี่ยน? ซิกเนเจอร์ของเมธอดจะแตกต่างไปหรือไม่? และโค้ดส่วนใดบ้างที่จะยังคงเดิมทุกประการ?

หลังจากได้เรียนรู้เกี่ยวกับลูป 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 {
    /// 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();
    }
}

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

โค้ดนี้สามารถคอมไพล์และรันได้จริง แต่ไม่ได้ให้ผลลัพธ์พฤติกรรมการทำงานของเธรดตามที่เราต้องการ กล่าวคือ คำขอที่ช้าจะยังคงทำให้คำขออื่น ๆ ต้องรอคอยอยู่เช่นเดิม เหตุผลเบื้องหลังค่อนข้างละเอียดอ่อน: struct Mutex ไม่มีเมธอด unlock แบบสาธารณะให้เรียกใช้ เนื่องจากสิทธิ์ในการครอบครองล็อกจะผูกอยู่กับช่วงอายุของ MutexGuard<T> ภายใน LockResult<MutexGuard<T>> ที่เมธอด lock คืนค่ากลับมา ในขั้นตอนคอมไพล์ ตัวตรวจการยืม (borrow checker) จึงสามารถบังคับใช้กฎที่ว่า ข้อมูลที่ได้รับการปกป้องโดย Mutex จะไม่สามารถเข้าถึงได้เลยเว้นแต่จะถือครองล็อกอยู่ ทว่าการทำงานในรูปแบบนี้อาจส่งผลให้การถือครองล็อกยาวนานเกินกว่าที่ตั้งใจไว้ หากเราไม่ได้ตระหนักถึงช่วงอายุของ MutexGuard<T> อย่างรอบคอบ

โค้ดในลิสติ้ง 21-20 ที่ใช้คำสั่ง let job = receiver.lock().unwrap().recv().unwrap(); ทำงานได้อย่างถูกต้องเพราะการใช้ let จะทำให้ค่าชั่วคราวใด ๆ ที่เกิดขึ้นในนิพจน์ (expression) ทางฝั่งขวาของเครื่องหมายเท่ากับถูกทำลายทิ้งทันทีเมื่อสเตตเมนต์ let สิ้นสุดลง ทว่าในทางตรงกันข้าม while let (รวมถึง if let และ match) จะไม่ทำลายค่าชั่วคราวทิ้งจนกว่าจะถึงจุดสิ้นสุดของบล็อกโค้ดนั้น ๆ ส่งผลให้ในลิสติ้ง 21-21 การครอบครองล็อกยังคงค้างอยู่ตลอดระยะเวลาที่คำสั่ง job() กำลังทำงาน ซึ่งหมายความว่าอินสแตนซ์ของ Worker ตัวอื่น ๆ จะไม่สามารถเข้ามาขอดึงงานไปทำได้เลยจนกว่างานปัจจุบันจะเสร็จสิ้น