Dari Server Single-Threaded ke Server Multithreaded
Saat ini, server memproses setiap request bergiliran, artinya ia tidak akan memproses koneksi kedua sampai koneksi pertama selesai diproses. Jika server menerima makin banyak request, eksekusi serial ini akan semakin tidak optimal. Jika server menerima request yang butuh waktu lama untuk diproses, request-request berikutnya harus menunggu sampai request yang lama itu selesai, meskipun request baru bisa diproses dengan cepat. Kita perlu memperbaiki ini, tetapi pertama-tama kita akan melihat masalahnya secara langsung.
Mensimulasikan Request yang Lambat
Kita akan melihat bagaimana sebuah request yang diproses secara lambat bisa memengaruhi request lain yang dikirim ke implementasi server kita saat ini. Listing 21-10 mengimplementasikan penanganan request ke /sleep dengan respons lambat yang disimulasikan, yang membuat server tidur selama lima detik sebelum merespons.
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();
}
Kita beralih dari if ke match sekarang karena kita punya tiga kasus. Kita perlu secara eksplisit mencocokkan slice dari request_line untuk melakukan pencocokan pola terhadap nilai literal string; match tidak melakukan referencing dan dereferencing otomatis seperti yang dilakukan metode equality.
Cabang pertama sama dengan blok if dari Listing 21-9. Cabang kedua mencocokkan request ke /sleep. Saat request itu diterima, server akan tidur selama lima detik sebelum merender halaman HTML yang berhasil. Cabang ketiga sama dengan blok else dari Listing 21-9.
Kamu bisa melihat betapa primitifnya server kita: library sungguhan akan menangani pengenalan banyak request dengan cara yang jauh lebih ringkas!
Jalankan server dengan cargo run. Lalu, buka dua jendela browser: satu untuk http://127.0.0.1:7878 dan satu lagi untuk http://127.0.0.1:7878/sleep. Jika kamu memasukkan URI / beberapa kali, seperti sebelumnya, kamu akan melihatnya merespons dengan cepat. Tetapi jika kamu memasukkan /sleep lalu memuat /, kamu akan melihat bahwa / menunggu sampai sleep menyelesaikan tidurnya selama lima detik penuh sebelum dimuat.
Ada beberapa teknik yang bisa kita pakai untuk mencegah request menumpuk di belakang request yang lambat, termasuk memakai async seperti yang kita lakukan di Bab 17; teknik yang akan kita implementasikan adalah thread pool.
Meningkatkan Throughput dengan Thread Pool
Sebuah thread pool adalah sekumpulan thread yang sudah di-spawn dan siap menunggu untuk menangani sebuah tugas. Saat program menerima tugas baru, ia menugaskan salah satu thread di pool ke tugas itu, dan thread tersebut akan memprosesnya. Thread-thread lain di pool tetap tersedia untuk menangani tugas lain yang masuk selagi thread pertama masih memproses. Setelah thread pertama selesai memproses tugasnya, ia dikembalikan ke kumpulan thread yang menganggur, siap menangani tugas baru. Thread pool memungkinkan kamu memproses koneksi secara concurrent, sehingga throughput server kamu meningkat.
Kita akan membatasi jumlah thread di pool ke angka yang kecil untuk melindungi kita dari serangan DoS; jika program kita membuat thread baru untuk setiap request yang masuk, seseorang yang mengirim 10 juta request ke server kita bisa membuat kacau dengan menghabiskan semua sumber daya server dan menghentikan pemrosesan request sama sekali.
Jadi, alih-alih membuat thread tanpa batas, kita akan punya jumlah thread tetap yang menunggu di pool. Request yang masuk dikirim ke pool untuk diproses. Pool akan menjaga antrean request yang masuk. Setiap thread di pool akan mengambil sebuah request dari antrean ini, menanganinya, lalu meminta request lain dari antrean. Dengan desain ini, kita bisa memproses hingga N request secara concurrent, dengan N adalah jumlah thread. Jika setiap thread sedang merespons request yang berjalan lama, request berikutnya tetap bisa menumpuk di antrean, tetapi kita sudah menambah jumlah request berjalan lama yang bisa kita tangani sebelum mencapai titik itu.
Teknik ini hanyalah salah satu dari banyak cara untuk meningkatkan throughput server web. Opsi lain yang bisa kamu jelajahi adalah model fork/join, model I/O async single-threaded, dan model I/O async multithreaded. Jika kamu tertarik dengan topik ini, kamu bisa membaca lebih lanjut tentang solusi lain dan mencoba mengimplementasikannya; dengan bahasa setingkat rendah seperti Rust, semua opsi ini mungkin dilakukan.
Sebelum mulai mengimplementasikan thread pool, mari kita bicarakan seperti apa penggunaan pool ini seharusnya. Saat kamu merancang kode, menulis antarmuka klien terlebih dahulu bisa membantu memandu desainmu. Tulis API kode sedemikian rupa sehingga tersusun seperti yang kamu ingin panggil; lalu, implementasikan fungsionalitas di dalam struktur itu, bukan mengimplementasikan fungsionalitas dulu baru merancang API publiknya.
Mirip dengan cara kita memakai pengembangan berbasis test di proyek Bab 12, di sini kita akan memakai pengembangan berbasis compiler. Kita akan menulis kode yang memanggil fungsi-fungsi yang kita inginkan, lalu melihat error dari compiler untuk menentukan apa yang harus kita ubah berikutnya agar kode berjalan. Namun, sebelum melakukan itu, kita akan menjelajahi teknik yang tidak akan kita pakai sebagai titik awal.
Membuat Thread untuk Setiap Request
Pertama, mari kita lihat seperti apa kode kita jika ia benar-benar membuat thread baru untuk setiap koneksi. Seperti disebutkan sebelumnya, ini bukan rencana final kita karena masalah potensial dalam membuat thread dalam jumlah tak terbatas, tetapi ini adalah titik awal untuk mendapatkan server multithreaded yang berjalan dulu. Lalu, kita akan menambahkan thread pool sebagai perbaikan, dan membandingkan kedua solusi akan lebih mudah.
Listing 21-11 menunjukkan perubahan yang perlu dibuat pada main untuk membuat thread baru guna menangani setiap stream di dalam loop 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();
}
Seperti yang kamu pelajari di Bab 16, thread::spawn akan membuat thread baru lalu menjalankan kode di dalam closure di thread baru itu. Jika kamu menjalankan kode ini dan memuat /sleep di browser, lalu / di dua tab browser lagi, kamu akan benar-benar melihat bahwa request ke / tidak perlu menunggu /sleep selesai. Namun, seperti yang kita sebutkan, pada akhirnya ini akan membebani sistem karena kamu membuat thread baru tanpa batas.
Kamu mungkin juga ingat dari Bab 17 bahwa ini adalah situasi yang tepat di mana async dan await benar-benar bersinar! Ingat itu saat kita membangun thread pool, dan pikirkan seperti apa perbedaan atau kesamaannya dengan async.
Membuat Jumlah Thread yang Terbatas
Kita ingin thread pool kita bekerja dengan cara yang serupa dan akrab, sehingga beralih dari thread ke thread pool tidak memerlukan perubahan besar pada kode yang memakai API kita. Listing 21-12 menunjukkan antarmuka hipotetis untuk struct ThreadPool yang ingin kita pakai sebagai pengganti 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 ideal kitaKita memakai ThreadPool::new untuk membuat thread pool baru dengan jumlah thread yang bisa dikonfigurasi, dalam hal ini empat. Lalu, di dalam loop for, pool.execute punya antarmuka yang mirip dengan thread::spawn, karena menerima closure yang harus dijalankan pool untuk setiap stream. Kita perlu mengimplementasikan pool.execute agar menerima closure itu dan memberikannya ke thread di pool untuk dijalankan. Kode ini belum akan terkompilasi, tetapi kita akan mencobanya agar compiler bisa memandu kita memperbaikinya.
Membangun ThreadPool dengan Pengembangan Berbasis Compiler
Lakukan perubahan dari Listing 21-12 pada src/main.rs, lalu mari kita pakai error compiler dari cargo check untuk memandu pengembangan kita. Berikut adalah error pertama yang kita dapatkan:
$ 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
Bagus! Error ini memberi tahu kita bahwa kita memerlukan tipe atau module ThreadPool, jadi kita akan membuatnya sekarang. Implementasi ThreadPool kita akan independen dari jenis pekerjaan yang dilakukan server web kita. Jadi, mari kita ubah crate hello dari binary crate menjadi library crate untuk menampung implementasi ThreadPool kita. Setelah berubah menjadi library crate, kita juga bisa memakai library thread pool yang terpisah untuk pekerjaan apa pun yang ingin kita lakukan dengan thread pool, tidak hanya untuk melayani request web.
Buat file src/lib.rs yang berisi kode berikut, yaitu definisi paling sederhana dari struct ThreadPool yang bisa kita punya untuk saat ini:
pub struct ThreadPool;
Lalu, edit file main.rs untuk membawa ThreadPool ke dalam scope dari library crate dengan menambahkan kode berikut di bagian atas 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();
}
Kode ini masih belum berjalan, tetapi mari kita cek lagi untuk mendapatkan error berikutnya yang perlu kita tangani:
$ 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
Error ini menunjukkan bahwa berikutnya kita perlu membuat fungsi asosiasi bernama new untuk ThreadPool. Kita juga tahu bahwa new perlu punya satu parameter yang bisa menerima 4 sebagai argumen dan harus mengembalikan instance ThreadPool. Mari kita implementasikan fungsi new paling sederhana yang punya karakteristik itu:
pub struct ThreadPool;
impl ThreadPool {
pub fn new(size: usize) -> ThreadPool {
ThreadPool
}
}
Kita memilih usize sebagai tipe parameter size karena kita tahu bahwa jumlah thread negatif tidak masuk akal. Kita juga tahu kita akan memakai 4 ini sebagai jumlah elemen dalam koleksi thread, yang memang itulah kegunaan tipe usize, seperti dibahas di bagian “Tipe Integer” Bab 3.
Mari kita cek kode lagi:
$ 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
Sekarang error muncul karena kita belum punya metode execute pada ThreadPool. Ingat dari bagian “Membuat Jumlah Thread yang Terbatas” bahwa kita memutuskan thread pool kita harus punya antarmuka serupa dengan thread::spawn. Selain itu, kita akan mengimplementasikan fungsi execute agar menerima closure yang diberikan kepadanya dan memberikannya ke thread menganggur di pool untuk dijalankan.
Kita akan mendefinisikan metode execute pada ThreadPool untuk menerima closure sebagai parameter. Ingat dari “Memindahkan Nilai yang Ditangkap keluar dari Closure” Bab 13 bahwa kita bisa menerima closure sebagai parameter dengan tiga trait berbeda: Fn, FnMut, dan FnOnce. Kita perlu memutuskan jenis closure mana yang dipakai di sini. Kita tahu kita akan melakukan sesuatu yang mirip dengan implementasi thread::spawn di library standar, jadi kita bisa melihat bound apa yang ada pada parameter di signature thread::spawn. Dokumentasi menunjukkan hal berikut:
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
F: FnOnce() -> T,
F: Send + 'static,
T: Send + 'static,
Parameter tipe F adalah yang kita perhatikan di sini; parameter tipe T berkaitan dengan nilai kembalian, dan kita tidak memperhatikannya. Kita bisa melihat bahwa spawn memakai FnOnce sebagai trait bound pada F. Ini kemungkinan besar memang yang kita inginkan, karena pada akhirnya kita akan meneruskan argumen yang kita terima di execute ke spawn. Kita bisa makin yakin bahwa FnOnce adalah trait yang ingin kita pakai karena thread untuk menjalankan sebuah request hanya akan mengeksekusi closure request itu satu kali, yang sesuai dengan Once dalam FnOnce.
Parameter tipe F juga punya trait bound Send dan lifetime bound 'static, yang berguna dalam situasi kita: Kita memerlukan Send untuk memindahkan closure dari satu thread ke thread lain dan 'static karena kita tidak tahu berapa lama thread akan membutuhkan waktu untuk mengeksekusi. Mari kita buat metode execute pada ThreadPool yang menerima parameter generic bertipe F dengan bound-bound ini:
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,
{
}
}
Kita tetap memakai () setelah FnOnce karena FnOnce ini mewakili closure yang tidak menerima parameter dan mengembalikan tipe unit (). Sama seperti definisi fungsi, tipe kembalian bisa dihilangkan dari signature, tetapi meskipun kita tidak punya parameter, tanda kurung tetap diperlukan.
Sekali lagi, ini adalah implementasi paling sederhana dari metode execute: ia tidak melakukan apa-apa, tetapi kita hanya berusaha membuat kode kita terkompilasi. Mari kita cek lagi:
$ cargo check
Checking hello v0.1.0 (file:///projects/hello)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.24s
Kode itu terkompilasi! Tetapi perhatikan bahwa jika kamu mencoba cargo run dan mengirim request lewat browser, kamu akan melihat error di browser seperti yang kita lihat di awal bab. Library kita sebenarnya belum memanggil closure yang diteruskan ke execute!
Catatan: Ada pepatah yang mungkin kamu dengar tentang bahasa dengan compiler yang ketat, seperti Haskell dan Rust, yaitu “Jika kode terkompilasi, kode itu berjalan.” Tetapi pepatah ini tidak selalu benar. Proyek kita terkompilasi, tetapi sama sekali tidak melakukan apa-apa! Jika kita sedang membangun proyek yang nyata dan lengkap, ini akan menjadi waktu yang tepat untuk mulai menulis unit test guna memeriksa bahwa kode terkompilasi dan punya perilaku yang kita inginkan.
Pikirkan: Apa yang akan berbeda di sini jika kita akan mengeksekusi future alih-alih closure?
Memvalidasi Jumlah Thread di new
Kita belum melakukan apa-apa dengan parameter new dan execute. Mari kita implementasi isi kedua fungsi ini dengan perilaku yang kita inginkan. Untuk mulai, mari kita pikirkan tentang new. Sebelumnya kita memilih tipe unsigned untuk parameter size karena pool dengan jumlah thread negatif tidak masuk akal. Namun, pool dengan nol thread juga tidak masuk akal, sementara nol adalah nilai usize yang sepenuhnya valid. Kita akan menambahkan kode untuk memeriksa bahwa size lebih besar dari nol sebelum mengembalikan instance ThreadPool, dan kita akan membuat program panic jika menerima nol dengan memakai macro assert!, seperti ditunjukkan pada Listing 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::new agar panic jika size nolKita juga telah menambahkan dokumentasi untuk ThreadPool kita dengan doc comment. Perhatikan bahwa kita mengikuti praktik dokumentasi yang baik dengan menambahkan bagian yang menyebutkan situasi-situasi di mana fungsi kita bisa panic, seperti dibahas di Bab 14. Coba jalankan cargo doc --open dan klik struct ThreadPool untuk melihat seperti apa dokumentasi new yang dihasilkan!
Alih-alih menambahkan macro assert! seperti yang kita lakukan di sini, kita bisa mengubah new menjadi build dan mengembalikan Result seperti yang kita lakukan dengan Config::build di proyek I/O pada Listing 12-9. Tetapi kita memutuskan dalam kasus ini bahwa mencoba membuat thread pool tanpa thread sama sekali seharusnya menjadi error yang tidak bisa dipulihkan. Jika kamu merasa ambisius, coba tulis fungsi bernama build dengan signature berikut untuk dibandingkan dengan fungsi new:
pub fn build(size: usize) -> Result<ThreadPool, PoolCreationError> {
Membuat Ruang untuk Menyimpan Thread
Sekarang kita punya cara untuk mengetahui bahwa kita memiliki jumlah thread yang valid untuk disimpan di pool, kita bisa membuat thread-thread itu dan menyimpannya di struct ThreadPool sebelum mengembalikan struct tersebut. Tetapi bagaimana cara kita “menyimpan” sebuah thread? Mari kita lihat lagi signature thread::spawn:
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
F: FnOnce() -> T,
F: Send + 'static,
T: Send + 'static,
Fungsi spawn mengembalikan JoinHandle<T>, dengan T adalah tipe yang dikembalikan closure. Mari kita coba memakai JoinHandle juga dan melihat apa yang terjadi. Dalam kasus kita, closure yang kita teruskan ke thread pool akan menangani koneksi dan tidak mengembalikan apa pun, sehingga T akan menjadi tipe unit ().
Kode pada Listing 21-14 akan terkompilasi, tetapi belum membuat thread apa pun. Kita telah mengubah definisi ThreadPool agar menyimpan vector berisi instance thread::JoinHandle<()>, menginisialisasi vector itu dengan kapasitas size, menyiapkan loop for yang akan menjalankan kode untuk membuat thread, dan mengembalikan instance ThreadPool yang berisi thread-thread itu.
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,
{
}
}
ThreadPool menyimpan threadKita telah membawa std::thread ke dalam scope di library crate karena kita memakai thread::JoinHandle sebagai tipe item di dalam vector pada ThreadPool.
Setelah ukuran yang valid diterima, ThreadPool kita membuat vector baru yang bisa menampung size item. Fungsi with_capacity melakukan tugas yang sama dengan Vec::new, tetapi dengan perbedaan penting: ia mengalokasikan ruang terlebih dahulu di vector. Karena kita tahu kita perlu menyimpan size elemen di vector, melakukan alokasi ini di awal sedikit lebih efisien daripada memakai Vec::new, yang mengubah ukurannya sendiri saat elemen disisipkan.
Saat kamu menjalankan cargo check lagi, seharusnya berhasil.
Mengirim Kode dari ThreadPool ke Thread
Kita meninggalkan komentar di loop for pada Listing 21-14 tentang pembuatan thread. Di sini, kita akan melihat bagaimana kita benar-benar membuat thread. Library standar menyediakan thread::spawn sebagai cara membuat thread, dan thread::spawn mengharapkan mendapat kode yang harus dijalankan thread begitu thread dibuat. Namun, dalam kasus kita, kita ingin membuat thread-thread itu dan membuat mereka menunggu kode yang akan kita kirim nanti. Implementasi thread di library standar tidak punya cara untuk melakukan itu; kita harus mengimplementasikannya sendiri.
Kita akan mengimplementasikan perilaku ini dengan memperkenalkan struktur data baru antara ThreadPool dan thread-thread yang akan mengelola perilaku baru ini. Kita menyebut struktur data ini Worker, istilah yang umum dalam implementasi pooling. Worker mengambil kode yang perlu dijalankan dan menjalankannya di thread-nya.
Bayangkan orang-orang yang bekerja di dapur sebuah restoran: para pekerja menunggu sampai pesanan datang dari pelanggan, lalu mereka bertugas mengambil pesanan itu dan menyiapkannya.
Alih-alih menyimpan vector berisi instance JoinHandle<()> di thread pool, kita akan menyimpan instance struct Worker. Setiap Worker akan menyimpan satu instance JoinHandle<()>. Lalu, kita akan mengimplementasikan metode pada Worker yang menerima closure berisi kode untuk dijalankan dan mengirimkannya ke thread yang sudah berjalan agar dieksekusi. Kita juga akan memberi setiap Worker sebuah id agar bisa membedakan antar-instance Worker di pool saat mencatat log atau melakukan debug.
Berikut adalah proses baru yang terjadi saat kita membuat ThreadPool. Kita akan mengimplementasikan kode yang mengirim closure ke thread setelah Worker kita siapkan dengan cara ini:
- Definisikan struct
Workeryang menyimpaniddanJoinHandle<()>. - Ubah
ThreadPoolagar menyimpan vector berisi instanceWorker. - Definisikan fungsi
Worker::newyang menerima angkaiddan mengembalikan instanceWorkeryang menyimpaniditu serta thread yang dibuat dengan closure kosong. - Di
ThreadPool::new, gunakan penghitung loopforuntuk menghasilkanid, buatWorkerbaru denganiditu, dan simpanWorkertersebut di dalam vector.
Jika kamu siap menghadapi tantangan, coba implementasikan perubahan ini sendiri sebelum melihat kode pada Listing 21-15.
Siap? Berikut adalah Listing 21-15 dengan salah satu cara untuk melakukan perubahan di atas.
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 agar menyimpan instance Worker, bukan menyimpan thread secara langsungKita telah mengubah nama field pada ThreadPool dari threads menjadi workers karena sekarang ia menyimpan instance Worker, bukan instance JoinHandle<()>. Kita memakai penghitung di loop for sebagai argumen untuk Worker::new, dan kita menyimpan setiap Worker baru di vector bernama workers.
Kode eksternal (seperti server kita di src/main.rs) tidak perlu tahu detail implementasi tentang pemakaian struct Worker di dalam ThreadPool, jadi kita membuat struct Worker dan fungsi new-nya bersifat private. Fungsi Worker::new memakai id yang kita berikan dan menyimpan instance JoinHandle<()> yang dibuat dengan membuat thread baru memakai closure kosong.
Catatan: Jika sistem operasi tidak bisa membuat thread karena sumber daya sistem tidak cukup,
thread::spawnakan panic. Hal itu akan membuat seluruh server kita panic, meskipun pembuatan sebagian thread mungkin berhasil. Demi kesederhanaan, perilaku ini tidak apa-apa, tetapi dalam implementasi thread pool untuk produksi, kamu kemungkinan ingin memakaistd::thread::Builderdan metodespawn-nya yang mengembalikanResult.
Kode ini akan terkompilasi dan menyimpan sejumlah instance Worker yang kita tentukan sebagai argumen untuk ThreadPool::new. Tetapi kita masih belum memproses closure yang kita terima di execute. Mari kita lihat cara melakukannya berikutnya.
Mengirim Request ke Thread melalui Channel
Masalah berikutnya yang akan kita tangani adalah closure yang diberikan kepada thread::spawn sama sekali tidak melakukan apa-apa. Saat ini, kita mendapat closure yang ingin kita jalankan di metode execute. Tetapi kita perlu memberikan thread::spawn sebuah closure untuk dijalankan saat kita membuat setiap Worker selama pembuatan ThreadPool.
Kita ingin struct Worker yang baru kita buat mengambil kode untuk dijalankan dari antrean yang disimpan di ThreadPool, lalu mengirim kode itu ke thread-nya untuk dijalankan.
Channel yang kita pelajari di Bab 16—cara sederhana untuk berkomunikasi antara dua thread—sangat cocok untuk kasus ini. Kita akan memakai channel sebagai antrean pekerjaan, dan execute akan mengirim pekerjaan dari ThreadPool ke instance Worker, yang lalu akan meneruskan pekerjaan itu ke thread-nya. Berikut rencananya:
ThreadPoolakan membuat channel dan menyimpan sender-nya.- Setiap
Workerakan menyimpan receiver-nya. - Kita akan membuat struct
Jobbaru yang menyimpan closure yang ingin kita kirim melalui channel. - Metode
executeakan mengirim pekerjaan yang ingin dijalankannya melalui sender. - Di thread-nya,
Workerakan melakukan loop pada receiver-nya dan mengeksekusi closure dari pekerjaan apa pun yang diterimanya.
Mari kita mulai dengan membuat channel di ThreadPool::new dan menyimpan sender di instance ThreadPool, seperti ditunjukkan pada Listing 21-16. Struct Job untuk saat ini tidak menyimpan apa pun, tetapi akan menjadi tipe item yang kita kirim melalui channel.
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 agar menyimpan sender dari channel yang mengirimkan instance JobDi ThreadPool::new, kita membuat channel baru dan membiarkan pool menyimpan sender-nya. Ini akan berhasil terkompilasi.
Mari kita coba meneruskan receiver channel ke setiap Worker saat thread pool membuat channel. Kita tahu kita ingin memakai receiver di thread yang dibuat oleh instance Worker, jadi kita akan mereferensikan parameter receiver di dalam closure. Kode pada Listing 21-17 belum sepenuhnya terkompilasi.
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 }
}
}
WorkerKita telah membuat beberapa perubahan kecil dan langsung: kita meneruskan receiver ke Worker::new, lalu memakainya di dalam closure.
Saat kita mencoba mengecek kode ini, kita mendapat error ini:
$ 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
Kode ini berusaha meneruskan receiver ke banyak instance Worker. Ini tidak akan berhasil, seperti yang kamu ingat dari Bab 16: implementasi channel yang disediakan Rust adalah producer ganda, consumer tunggal. Ini berarti kita tidak bisa sekadar meng-clone ujung konsumsi dari channel untuk memperbaiki kode ini. Kita juga tidak ingin mengirim sebuah pesan berkali-kali ke banyak consumer; kita ingin satu daftar pesan dengan banyak instance Worker sehingga setiap pesan diproses satu kali.
Selain itu, mengambil pekerjaan dari antrean channel melibatkan perubahan pada receiver, sehingga thread-thread itu butuh cara aman untuk berbagi dan mengubah receiver; jika tidak, kita bisa mengalami race condition (seperti dibahas di Bab 16).
Ingat smart pointer yang aman untuk thread yang dibahas di Bab 16: Untuk berbagi ownership ke beberapa thread dan mengizinkan thread-thread itu mengubah nilainya, kita perlu memakai Arc<Mutex<T>>. Tipe Arc akan memungkinkan banyak instance Worker memiliki receiver, dan Mutex akan memastikan hanya satu Worker yang mendapat pekerjaan dari receiver pada satu waktu. Listing 21-18 menunjukkan perubahan yang perlu kita buat.
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 }
}
}
Worker memakai Arc dan MutexDi ThreadPool::new, kita menaruh receiver di dalam Arc dan Mutex. Untuk setiap Worker baru, kita meng-clone Arc untuk menaikkan jumlah reference agar instance Worker bisa berbagi ownership atas receiver.
Dengan perubahan ini, kode terkompilasi! Kita makin dekat!
Mengimplementasikan Metode execute
Akhirnya, mari kita implementasikan metode execute pada ThreadPool. Kita juga akan mengubah Job dari struct menjadi alias tipe untuk trait object yang menyimpan tipe closure yang diterima execute. Seperti dibahas di bagian “Sinonim Tipe dan Alias Tipe” Bab 20, alias tipe memungkinkan kita membuat tipe yang panjang menjadi lebih pendek agar lebih mudah dipakai. Lihat Listing 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 untuk Box yang menyimpan setiap closure, lalu mengirim pekerjaan melalui channelSetelah membuat instance Job baru dengan closure yang kita dapatkan di execute, kita mengirim pekerjaan itu melalui ujung pengirim channel. Kita memanggil unwrap pada send untuk mengantisipasi kasus pengiriman gagal. Ini bisa terjadi, misalnya, jika kita menghentikan semua thread kita dari eksekusi, yang berarti ujung penerima sudah berhenti menerima pesan baru. Saat ini, kita tidak bisa menghentikan thread-thread kita dari eksekusi: thread kita terus berjalan selama pool ada. Alasan kita memakai unwrap adalah kita tahu kasus gagal itu tidak akan terjadi, tetapi compiler tidak tahu itu.
Tapi kita belum sepenuhnya selesai! Di Worker, closure yang kita teruskan ke thread::spawn masih hanya mereferensikan ujung penerima channel. Sebaliknya, kita perlu closure itu melakukan loop selamanya, meminta pekerjaan dari ujung penerima channel dan menjalankannya saat mendapat satu. Mari kita buat perubahan seperti ditunjukkan pada Listing 21-20 pada 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 {
/// 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 }
}
}
WorkerDi sini, kita pertama memanggil lock pada receiver untuk mendapatkan mutex, lalu memanggil unwrap agar panic jika ada error. Mendapatkan lock bisa gagal jika mutex berada dalam keadaan poisoned, yang bisa terjadi jika thread lain panic saat memegang lock, alih-alih melepaskannya. Dalam situasi ini, memanggil unwrap agar thread ini panic adalah tindakan yang tepat. Silakan ubah unwrap ini menjadi expect dengan pesan error yang bermakna bagimu.
Jika kita berhasil mendapat lock pada mutex, kita memanggil recv untuk menerima Job dari channel. Sebuah unwrap terakhir juga mengabaikan error di sini, yang bisa terjadi jika thread yang memegang sender sudah mati, mirip dengan cara metode send mengembalikan Err jika receiver mati.
Panggilan ke recv memblokir, jadi jika belum ada pekerjaan, thread saat ini akan menunggu sampai ada pekerjaan tersedia. Mutex<T> memastikan bahwa hanya satu thread Worker pada satu waktu yang mencoba meminta pekerjaan.
Thread pool kita sekarang sudah berfungsi! Coba cargo run dan kirim beberapa request:
$ 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.
Berhasil! Sekarang kita punya thread pool yang mengeksekusi koneksi secara asynchronous. Jumlah thread yang dibuat tidak pernah lebih dari empat, sehingga sistem kita tidak akan kewalahan jika server menerima banyak request. Jika kita mengirim request ke /sleep, server akan tetap bisa melayani request lain dengan menjalankannya di thread lain.
Catatan: Jika kamu membuka /sleep di beberapa jendela browser secara bersamaan, halaman itu mungkin memuat satu per satu dengan interval lima detik. Beberapa browser web menjalankan beberapa instance dari request yang sama secara berurutan demi alasan caching. Keterbatasan ini bukan disebabkan oleh server web kita.
Ini adalah waktu yang tepat untuk berhenti sejenak dan memikirkan seperti apa kode di Listing 21-18, 21-19, dan 21-20 jika kita memakai future alih-alih closure untuk pekerjaan yang dilakukan. Tipe apa yang akan berubah? Bagaimana signature metode akan berbeda, jika ada? Bagian kode mana yang tetap sama?
Setelah mempelajari loop while let di Bab 17 dan Bab 19, kamu mungkin bertanya-tanya mengapa kita tidak menulis kode thread Worker seperti ditunjukkan pada Listing 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 }
}
}
Worker::new memakai while letKode ini terkompilasi dan berjalan, tetapi tidak menghasilkan perilaku thread yang diinginkan: request yang lambat tetap akan membuat request lain menunggu untuk diproses. Alasannya agak halus: struct Mutex tidak punya metode unlock publik karena ownership atas lock didasarkan pada lifetime dari MutexGuard<T> di dalam LockResult<MutexGuard<T>> yang dikembalikan metode lock. Saat kompilasi, borrow checker lalu bisa menegakkan aturan bahwa sumber daya yang dijaga oleh Mutex tidak bisa diakses kecuali kita memegang locknya. Namun, implementasi ini juga bisa membuat lock dipegang lebih lama dari yang dimaksudkan jika kita tidak memperhatikan lifetime dari MutexGuard<T>.
Kode pada Listing 21-20 yang memakai let job = receiver.lock().unwrap().recv().unwrap(); berhasil karena dengan let, semua nilai sementara yang dipakai dalam ekspresi di sisi kanan tanda sama dengan langsung dihapus saat statement let berakhir. Namun, while let (dan if let serta match) tidak menghapus nilai sementara sampai akhir blok terkait. Di Listing 21-21, lock tetap dipegang selama panggilan job() berlangsung, yang berarti instance Worker lain tidak bisa menerima pekerjaan.