在这个章节中,我们要用最基础的方式透过 TCP 的监听与连接,解析与发送符合 HTTP 格式的消息,来完成我们的 Web 服务器。至于会选择用这样的方式来制作 Web 服务器的原因是,要练习把我们在先前的章节中学到的东西加以应用。毕竟现在 crates.io 上已经有很多现成的 Web 框架(Web Framework)可以使用,正常来讲我们是不需要从底层刻出 Web 服务器的。

创建单线程的 Web 服务器

虽然我们的目标是要创建多线程的 Web 服务器,但是一开始还是先把问题简化会比较容易处理。就让我们先想办法创建单线程的 Web 服务器吧!

提醒一下,在这个章节中不会介绍计算机网络的概念,会预设各位早就已经对这个领域驾轻就熟了。

创建项目

先使用以下指令,创建出 Cargo 的应用程序项目,项目名称为 hello_web:

cargo new --bin hello_web

监听 TCP Socket

Rust 编程语言的标准函数库中的 std::net 模块,提供了一些基本的 TCP 和 UDP 的相关工具。我们可以使用其中的 TcpListener 结构体来监听指定的 TCP Socket 地址。main.rs 文件的代码如下:

use std::net::TcpListener;

const PORT: i32 = 3000;

fn main() {
    let listener = TcpListener::bind(format!("127.0.0.1:{PORT}")).unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        println!("Connection established!");
    }
}

TcpListener 结构体的 bind 关联函数可以让我们借由绑定某个 TCP Socket 地址的方式来产生出 TcpListener 的结构实体。PORT 常数就是我们的 HTTP Server 要监听的端口号,在开发阶段,建议不要使用「0~1023」的数值范围,因为这个范围的端口号被操作系统保留使用,如果应用程序要使用这个范围的端口号,将需要 root 运行权限,因此我们这里将其设为 3000。而使用 PORT 常数的原因是,当程序日后需要改 HTTP Server 监听的端口号时,可以直接改动源代码中常数的值,非常方便。

TcpListener 结构实体的 incoming 方法会回传一个 Incoming 迭代器。在程序运行的时候,如果有一个客户端想要使用 TCP 连到 127.0.0.1:3000,Incoming 迭代器就会进行一次迭代,回传一个 Result 枚举实体,其 Ok 变体会包裹一个 TcpStream 结构实体。此时 TCP 连接就创建起来了,我们无需自行实作 TCP 连接的三向交握(Three-way Handshake)。

我们可以运行一下这个项目,并打开网页浏览器,在网页浏览器的网址列输入 http://127.0.0.1:3000 网址,并尝试打开它。此时网页浏览器应该会出现「无法连上这个网站」的画面,但是再回头看看我们的终端机画面,会多出几行 Connection established! 消息,表示我们的 TcpStream 结构实体有成功被创建出来。

终端机印出的 Connection established! 消息

虽然我们只是打开一次 http://127.0.0.1:3000 网址,但是有些网页浏览器除了会去链接到 http://127.0.0.1:3000 网址之外,同时还会尝试去取得 http://127.0.0.1:3000/favicon.ico(网站图标)等等的资源。因此虽然我们只让网页浏览器打开一次 http://127.0.0.1:3000 网址,可能就会对服务器发送好几个连接请求,所以印出好几行 Connection established! 消息是正常的。

我们可以刷新「无法连上这个网站」的画面,依然会看到「无法连上这个网站」的画面,但是再回头看一下终端机画面,又会多出几行 Connection established! 消息。这就表示我们刚才写的程序 Incoming 迭代器会不断地在有客户端连接进来的时候,每次去产生出新的 TcpStream 结构实体,完全不需要重开程序就能持续处理多个 TCP 连接的任务。

读取客户端传来的 HTTP 消息

客户端发送的 HTTP 消息,我们称之为「请求」(request)。为了避免 main 函数太长,我们通常会将处理 HTTP 请求的程序写在别的地方,可能会是别的函数,也可能会是别的模块。在此我们直接在 main.rs 文件中加上 handle_connection 函数,并定义其参数可以传入一个 TcpStream 结构实体。

use std::net::{TcpListener, TcpStream};

const PORT: i32 = 3000;

fn main() {
    let listener = TcpListener::bind(format!("127.0.0.1:{PORT}")).unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        handle_connection(stream);
    }
}

fn handle_connection(stream: TcpStream) {
    println!("Connection established!");
}

我们可以使用 TcpStream 结构实体提供的 read 方法,来读取输入串流中的数据。这个 read 方法需要从参数输入一个 u8 类型的数组,用来当作缓冲空间使用。read 方法并不会一次把输入串流中的数据读完,而是一次读一小块,我们需要提供一个内存空间让它存放读取到的数据,它会将它读取到的数据量以 Result 枚举实体来包裹回传。在使用 read 方法时,TcpStream 结构实体本身用来记录数据位置的字段会发生变化,因此我们需要让 stream 变量为可变的。于是乎,我们将程序修改如下:

use std::{
    io::prelude::*,
    net::{TcpListener, TcpStream},
};

const PORT: i32 = 3000;

fn main() {
    let listener = TcpListener::bind(format!("127.0.0.1:{PORT}")).unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        handle_connection(stream);
    }
}

fn handle_connection(mut stream: TcpStream) {
    println!("Connection established!");

    let mut buffer = [0; 512];

    let c = stream.read(&mut buffer).unwrap();
}

缓冲空间需要多大,其实没有硬性规定,需看程序使用情境来决定。在此我们设置为 512 个字节(u8),足够让我们的程序可以调用一次 read 方法就把输入串流中的该读的数据读完。Rust 编程语言的标准函数库所提供的 std::io::prelude 模块,实作 I/O 相关的常用功能,在进行 I/O 操作时,如果我们对 I/O 读写没有特别请求的话,可以直接将这个模块引用至目前程序的 scope 下。

再来要将读到的数据转成字符串,我们可以使用 String 结构体提供的 from_utf8_lossy 关联函数将 u8 类型的数组切片转成 Cow<str> 枚举实体。这个 Cow 枚举实体是一个智能型指针,其名称「Cow」表示「Clone-on-write」,当要使用其 to_mut 方法取得其所指到的实体的可变参考时,如果实体的拥有者不是这个 Cow 智能型指针时(即这个智能型指针是指到该实体的不可变参考,而不是直接指到该实体),Cow 智能型指针就会先拷贝出新的实体,并且改为指到这个新实体,再把其可变参考回传,这个新实体的拥有者即为该 Cow 智能型指针,因此下次再使用 to_mut 方法时就不会再去拷贝新实体了。

程序修改如下:

use std::{
    io::prelude::*,
    net::{TcpListener, TcpStream},
};

const PORT: i32 = 3000;

fn main() {
    let listener = TcpListener::bind(format!("127.0.0.1:{PORT}")).unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        handle_connection(stream);
    }
}

fn handle_connection(mut stream: TcpStream) {
    let mut buffer = [0; 512];

    let c = stream.read(&mut buffer).unwrap();

    let request = String::from_utf8_lossy(&buffer[0..c]);

    println!("Request: {request}");
}

from_utf8_lossy 关联函数还可以将 u8 类型的数组切片中,不能被正常使用 UTF8 编码为字符串的数据以 � 字符取代。

运行程序项目试试,接着同样使用网页浏览器打开 http://127.0.0.1:3000 网址,终端机结果如下:

印出 HTTP 请求内容的终端机

发送 HTTP 消息给客户端

发送 HTTP 消息给客户端,我们称之为「回应」(response)。我们可以使用 TcpStream 结构实体提供的 write_all 方法,来将数据写入至输出串流中。使用 flush 方法,可以确保先前写入、暂存在缓冲区中的数据都被送出去。不过 TcpStream 本身并没有缓冲区,所以它的 flush 方法其实什么事都不会做。

程序修改如下:

use std::{
    io::prelude::*,
    net::{TcpListener, TcpStream},
};

const PORT: i32 = 3000;

fn main() {
    let listener = TcpListener::bind(format!("127.0.0.1:{PORT}")).unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        handle_connection(stream);
    }
}

fn handle_connection(mut stream: TcpStream) {
    let mut buffer = [0; 512];

    let c = stream.read(&mut buffer).unwrap();

    let request = String::from_utf8_lossy(&buffer[0..c]);

    let content = "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Hello!</h1>
        <p>Hi from Rust</p>
    </body>
</html>
";

    let response = format!(
        "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{content}",
        content.len()
    );

    stream.write_all(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}

以上程序的 response 变量所保存的字符串,有在 HTTP 消息的 Body 中代入 HTML。运行程序项目试试,接着同样使用网页浏览器打开 http://127.0.0.1:3000 网址,就能看到我们的首页了!

浏览器显示的 Hello! 首页

可是当我们尝试打开 http://127.0.0.1:3000/test 网址时,也会看到跟首页一样的画面,那是因为现阶段我们完全没有去解析(parse)用户的 HTTP 请求,看他到底是要访问哪个页面。于是,我们可以将程序修改如下:

use std::{
    io::prelude::*,
    net::{TcpListener, TcpStream},
};

const PORT: i32 = 3000;

fn main() {
    let listener = TcpListener::bind(format!("127.0.0.1:{PORT}")).unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        handle_connection(stream);
    }
}

fn handle_connection(mut stream: TcpStream) {
    let mut buffer = [0; 512];

    let c = stream.read(&mut buffer).unwrap();

    let request = String::from_utf8_lossy(&buffer[0..c]);

    let page404 = || {
        let content = "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Oops!</h1>
        <p>Sorry, I don't know what you're asking for.</p>
    </body>
</html>
";

        format!(
            "HTTP/1.1 404 NOT FOUND\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{content}",
            content.len()
        )
    };

    let page200 = |content: &str| {
        format!(
            "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{content}",
            content.len()
        )
    };

    let response = if request.starts_with("GET") {
        let request = &request["GET".len() + 1..];
        let path = &request[..request.find(' ').unwrap()];

        match path {
            "/" => page200(
                "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Hello!</h1>
        <p>Hi from Rust</p>
    </body>
</html>
",
            ),
            _ => page404(),
        }
    } else {
        page404()
    };

    stream.write_all(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}

程序第 52 行,使用了字符串的 starts_with 方法,先判断用户发送的 HTTP 请求是否以「GET」(HTTP 请求方法的一种)开头,如果是的话就继续进行解析;如果不是使用「GET」方法的话,就直接回传 404 页面的 HTTP 回应。

程序第 53 行和第 54 行,我们将用户想要访问的 URI 路径解析出来,存进 path 变量。程序第 56 行开始的 match 关键字,对 path 变量的值做型样匹配,就像是在做路由(routing)。如果匹配到 / 就回传首页的 HTTP 回应,如果是其它的,就回传 404 页面的 HTTP 回应。

接着运行程序项目试试,然后同样使用网页浏览器分别打开 http://127.0.0.1:3000 网址和 http://127.0.0.1:3000/test 网址,就可以看到我们的 404 页面有在正常工作啦!

浏览器显示的 404 页面

创建多线程的 Web 服务器

在创建多线程的 Web 服务器之前,我们先来模拟一个情境,假设我们的 Web 服务器,处理某个用户的请求需要比较长(可能数秒、甚至数分钟)的时间。此时如果又有新的请求进来会发生什么事呢?我们先将程序改写如下:

use std::{
    io::prelude::*,
    net::{TcpListener, TcpStream},
    thread,
    time::Duration,
};

const PORT: i32 = 3000;

fn main() {
    let listener = TcpListener::bind(format!("127.0.0.1:{PORT}")).unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        handle_connection(stream);
    }
}

fn handle_connection(mut stream: TcpStream) {
    let mut buffer = [0; 512];

    let c = stream.read(&mut buffer).unwrap();

    let request = String::from_utf8_lossy(&buffer[0..c]);

    let page404 = || {
        let content = "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Oops!</h1>
        <p>Sorry, I don't know what you're asking for.</p>
    </body>
</html>
";

        format!(
            "HTTP/1.1 404 NOT FOUND\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{content}",
            content.len()
        )
    };

    let page200 = |content: &str| {
        format!(
            "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{content}",
            content.len()
        )
    };

    let response = if request.starts_with("GET") {
        let request = &request["GET".len() + 1..];
        let path = &request[..request.find(' ').unwrap()];

        match path {
            "/" => page200(
                "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Hello!</h1>
        <p>Hi from Rust</p>
    </body>
</html>
",
            ),
            "/search" => {
                thread::sleep(Duration::from_secs(15));

                page200(
                    "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Search Result</h1>
        <p>Found nothing.</p>
    </body>
</html>
",
                )
            },
            _ => page404(),
        }
    } else {
        page404()
    };

    stream.write_all(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}

程序第 73 行开始,我们添加了 /search 路径,当网页浏览器去打开 http://127.0.0.1:3000/search 网址时,程序会调用 std::thread 模块的 sleep 函数,来模拟搜索 15 秒的过程。在程序处理搜索请求的 15 秒内,此时如果我们另开新分页,去尝试打开首页,也就是 http://127.0.0.1:3000 网址,会发现首页会在 http://127.0.0.1:3000/search 的页面打开后才会被打开。

就是因为我们目前的 Web 服务器只有支持单线程,无法同时处理不同的 HTTP 请求,而造成后来的 HTTP 请求必须等待的情形。所以现在我们要让我们的 Web 服务器支持多线程,改善其吞吐量(throughput)。

由于我们已经把处理 HTTP 请求的程序都写在 handle_connection 函数,我们只需要在每次创建出 TcpStream 结构实体后,都去创建新的线程来调用 handle_connection 函数,即可让我们的 Web 服务器支持多线程。

程序修改如下:

use std::{
    io::prelude::*,
    net::{TcpListener, TcpStream},
    thread,
    time::Duration,
};

const PORT: i32 = 3000;

fn main() {
    let listener = TcpListener::bind(format!("127.0.0.1:{PORT}")).unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        thread::spawn(|| handle_connection(stream));
    }
}

fn handle_connection(mut stream: TcpStream) {
    let mut buffer = [0; 512];

    let c = stream.read(&mut buffer).unwrap();

    let request = String::from_utf8_lossy(&buffer[0..c]);

    let page404 = || {
        let content = "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Oops!</h1>
        <p>Sorry, I don't know what you're asking for.</p>
    </body>
</html>
";

        format!(
            "HTTP/1.1 404 NOT FOUND\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{content}",
            content.len()
        )
    };

    let page200 = |content: &str| {
        format!(
            "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{content}",
            content.len()
        )
    };

    let response = if request.starts_with("GET") {
        let request = &request["GET".len() + 1..];
        let path = &request[..request.find(' ').unwrap()];

        match path {
            "/" => page200(
                "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Hello!</h1>
        <p>Hi from Rust</p>
    </body>
</html>
",
            ),
            "/search" => {
                thread::sleep(Duration::from_secs(15));

                page200(
                    "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Search Result</h1>
        <p>Found nothing.</p>
    </body>
</html>
",
                )
            },
            _ => page404(),
        }
    } else {
        page404()
    };

    stream.write_all(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}

接着用同样的方式打开 http://127.0.0.1:3000 网址和 http://127.0.0.1:3000/search 网址,就会发现,等待前一次 HTTP 请求处理完才会处理下一次 HTTP 请求的问题已经解决了!

使用线程池(thread pool)增加程序的安全性

我们目前程序的多线程作法,是在每次创建出 TcpStream 结构实体后,都去创建新的线程来调用 handle_connection 函数。也就是说,如果我们的服务器在短时间内突然来了很多 HTTP 请求(例如遭到 DDOS 攻击),假设每秒有一万个 HTTP 请求同时进来,程序理论上每秒就需要创建出一万个线程来处理,就算一开始我们的内存够大能够负荷一万个线程,但是我们不太可能会有一万个处理器(处理器内核)来同时快速地将一万个 HTTP 请求在 1 秒内处理完。前一秒的 HTTP 请求都还没处理完,下一秒又有大量的 HTTP 请求进来,内存迟早会不够用。因此,我们必须限制我们的程序,在同一时间用来处理每个 HTTP 请求的线程数量。

我们可以实作一个简单的线程池,用固定数量的线程,来依序完成队列(Queue)里的任务。

在同样的 hello_web 应用程序项目的 src 目录中,添加 lib.rs 文件,撰写我们的线程池程序。代码如下:

pub struct ThreadPool;

ThreadPool 结构体代表我们之后会使用到的线程池,每个 ThreadPool 结构实体都是一个线程池。接着替 ThreadPool 结构体实作 new 关联函数,程序如下:

pub struct ThreadPool;

impl ThreadPool {
    pub fn new(size: usize) -> ThreadPool {
        assert!(size > 0);

        ThreadPool
    }
}

new 关联函数的 size 参数表示要使用的线程数量,如果这个数量不大于 0 的话,就直接让程序发生 panic。

我们希望 ThreadPool 结构体也有类似 spawn 的方法,能够从参数传入要在新线程内运行的闭包。参考一下 std::thread 模块内的 spawn 函数的定义:

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

我们发现 spawn 函数是利用泛型来传递闭包,且这个闭包可以是任意的闭包(所有闭包都有实作 FnOnce 特性),且必须要实作 Send 特性。Send 特性类似先前提过的 Sized 特性,在编译阶段,如果编译器认为类型适合使用在多线程,就会自动实作 Send 特性。闭包使用到的外部资源的参考,其生命周期也必须是 'static,因为编译器不知道新的线程会运行多久,要确保在新线程结束之前所参考到的外部资源都还存在。

总而言之,我们就照着 spawn 函数的定义来替我们的 ThreadPool 结构体完成 execute 函数吧!程序如下:

pub struct ThreadPool;

impl ThreadPool {
    pub fn new(size: usize) -> ThreadPool {
        assert!(size > 0);

        ThreadPool
    }

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

我们的程序并不需要使用到闭包的回传值,因此可以将程序简化如下:

pub struct ThreadPool;

impl ThreadPool {
    pub fn new(size: usize) -> ThreadPool {
        assert!(size > 0);

        ThreadPool
    }

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

spawn 函数会回传 JoinHandle 实体,我们姑且就把这个当作是线程实体吧!我们需要在 new 关联函数内,利用 size 参数,来产生出相对应数量的线程实体,并保存在 ThreadPool 结构实体中。程序如下:

use std::thread::JoinHandle;

pub struct ThreadPool {
    threads: Vec<JoinHandle<()>>,
}

impl ThreadPool {
    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, but how?
        }

        ThreadPool {
            threads
        }
    }

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

以上程序第 11 行,我们使用了 Vec 结构体的 with_capacity 关联函数来创建出预设容量的 Vec 结构实体,即便新建出来的 Vec 结构实体还没有存放任何元素,它也会先在内存中配置好传入的容量大小(元素数量)。如此一来,之后我们要将新元素加入至 Vec 结构实体时,在容量未满之前,就不需要去进行内存的重新配置动作,可以让程序性能稍微好一点。

程序第 14 行,我们虽然知道应该要产生线程的实体并加入至 threads 这个 Vec 结构实体内,但是线程的实体要怎么产生呢?如果直接使用 std::thread 模块提供的 spawn 函数,就需要传入新线程要运行的闭包给它,而且新线程在创建出来后会立刻运行传入的闭包。为了要让新线程可以等待 ThreadPool 结构实体使用 execute 方法传入的闭包,我们需要替每个线程实作一些与 ThreadPool 结构实体同步的方式。为了简化程序,我们要再实作两个类型,分别是 Worker(工人)结构体、和 Job(工作)类型别名,每个 Worker 结构实体都负责处理一个线程,并提供能够让其负责的线程随时运行 Job 闭包的方法。将程序改写如下:

use std::{
    sync::{
        mpsc::{self, Receiver, Sender},
        Arc,
    },
    thread::{self, JoinHandle},
};

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

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

impl ThreadPool {
    pub fn new(size: usize) -> ThreadPool {
        assert!(size > 0);

        let (sender, receiver) = mpsc::channel();

        let receiver = Arc::new(receiver);

        let mut workers = Vec::with_capacity(size);

        for id in 0..size {
            workers.push(Worker::new(id, receiver.clone()));
        }

        ThreadPool {
            workers,
            sender,
        }
    }

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

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

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

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

            println!("Worker {id} got a job; executing.");

            job();
        });

        Worker {
            id,
            thread,
        }
    }
}

以上程序会编译错误,因为 Receiver 结构体并没有实作 Sync 特性,它无法直接被多个线程共用。因此,我们必须要搭配 Mutex 结构体一起使用。另外再多注意一下第 55 行,job 变量此时的类型虽然为被 Box 智能型指针参考的闭包,不过我们依然还是可以直接用原先调用函数的方式来调用闭包。

将程序加上 Mutex 结构体,修改如下:

use std::{
    sync::{
        mpsc::{self, Receiver, Sender},
        Arc, Mutex,
    },
    thread::{self, JoinHandle},
};

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

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

impl ThreadPool {
    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, receiver.clone()));
        }

        ThreadPool {
            workers,
            sender,
        }
    }

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

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

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

impl Worker {
    fn new(id: usize, receiver: Arc<Mutex<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,
        }
    }
}

如此一来我们的 ThreadPool 结构体就可以使用了,接着将 main.rs 文件的代码修改如下:

use std::{
    io::prelude::*,
    net::{TcpListener, TcpStream},
    thread,
    time::Duration,
};

use hello_web::ThreadPool;

const PORT: i32 = 3000;
const WORKER_SIZE: usize = 8;

fn main() {
    let listener = TcpListener::bind(format!("127.0.0.1:{PORT}")).unwrap();
    let pool = ThreadPool::new(WORKER_SIZE);

    for stream in listener.incoming() {
        let stream = stream.unwrap();

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

fn handle_connection(mut stream: TcpStream) {
    let mut buffer = [0; 512];

    let c = stream.read(&mut buffer).unwrap();

    let request = String::from_utf8_lossy(&buffer[0..c]);

    let page404 = || {
        let content = "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Oops!</h1>
        <p>Sorry, I don't know what you're asking for.</p>
    </body>
</html>
";

        format!(
            "HTTP/1.1 404 NOT FOUND\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{content}",
            content.len()
        )
    };

    let page200 = |content: &str| {
        format!(
            "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{content}",
            content.len()
        )
    };

    let response = if request.starts_with("GET") {
        let request = &request["GET".len() + 1..];
        let path = &request[..request.find(' ').unwrap()];

        match path {
            "/" => page200(
                "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Hello!</h1>
        <p>Hi from Rust</p>
    </body>
</html>
",
            ),
            "/search" => {
                thread::sleep(Duration::from_secs(15));

                page200(
                    "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Search Result</h1>
        <p>Found nothing.</p>
    </body>
</html>
",
                )
            },
            _ => page404(),
        }
    } else {
        page404()
    };

    stream.write_all(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}

使用 WORKER_SIZE 常数来表示线程池要使用的线程数量,在此设为 8,表示使用 8 个线程。我们可以运行程序项目,随便使用浏览器快速打开数次 http://127.0.0.1:3000 网址和 http://127.0.0.1:3000/search 网址来试试。会发现到,当程序正在处理的 HTTP 请求超过 8 个时,之后进去的 HTTP 请求便需要等待,这就表示我们的线程池有正常工作!

线程池处理多个请求的终端机消息

可安全关闭的 Web 服务器

不知道各位在尝试运行我们刚才制作的 Web 服务器时有没有发现,我们在关闭 Web 服务器应用程序时,必须按 Ctrl + C 或是直接把终端机关掉,才能把我们制作的 Web 服务器程序关闭。虽然很多 Web 服务器应用程序都是一样,只能使用这样的方式关闭,但像这样强制中断程序的运行,会让正在处理中的 HTTP 请求被切断,可能会破坏数据库或是文件系统的一致性,导致服务出现问题。

为了让我们的 Web 服务器程序能够安全地关闭,我们需要先替我们的 ThreadPool 结构体实作 Drop 特性,在 drop 方法中将所有的线程 join 进来运行,确保 ThreadPool 结构实体在被消灭之前,要先结束其所有线程的运行。

程序修改如下:

use std::{
    sync::{
        mpsc::{self, Receiver, Sender},
        Arc, Mutex,
    },
    thread::{self, JoinHandle},
};

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

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

impl ThreadPool {
    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, receiver.clone()));
        }

        ThreadPool {
            workers,
            sender,
        }
    }

    pub fn execute<F: FnOnce() + Send + 'static>(&self, f: F) {
        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: JoinHandle<()>,
}

impl Worker {
    fn new(id: usize, receiver: Arc<Mutex<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,
        }
    }
}

程序第 48 行会编译失败,因为调用 JoinHandle 结构实体的 join 方法必须要改变 JoinHandle 结构实体的拥有者,但是我们现在的 JoinHandle 结构实体的拥有者是 Worker 结构实体的 thread 字段,无法直接改变。因此我们必须要更改 Worker 结构体的定义,使其 thread 字段保存的值为 Option 枚举实体,如此一来我们才能使用 Option 枚举实体的 take 方法,来转移这个 Option 枚举实体的拥有者。

程序修改如下:

use std::{
    sync::{
        mpsc::{self, Receiver, Sender},
        Arc, Mutex,
    },
    thread::{self, JoinHandle},
};

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

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

impl ThreadPool {
    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, receiver.clone()));
        }

        ThreadPool {
            workers,
            sender,
        }
    }

    pub fn execute<F: FnOnce() + Send + 'static>(&self, f: F) {
        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.take().unwrap().join().unwrap();
        }
    }
}

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

impl Worker {
    fn new(id: usize, receiver: Arc<Mutex<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: Some(thread),
        }
    }
}

接着,我们不能让 Worker 结构实体的每个线程一直运行无穷循环。要有个方式能让每个线程接收到「程序目前正在关闭,快点跳出循环」的消息,使它们能够结束运行。我们同样可以透过消息传递,来完成这个功能。程序修改如下:

use std::{
    sync::{
        mpsc::{self, Receiver, Sender},
        Arc, Mutex,
    },
    thread::{self, JoinHandle},
};

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

enum Message {
    NewJob(Job),
    Terminate,
}

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

impl ThreadPool {
    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, receiver.clone()));
        }

        ThreadPool {
            workers,
            sender,
        }
    }

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

        self.sender.send(Message::NewJob(job)).unwrap();
    }
}

impl Drop for ThreadPool {
    fn drop(&mut self) {
        println!("Sending terminate message to all workers.");

        for _ in &mut self.workers {
            self.sender.send(Message::Terminate).unwrap();
        }

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

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

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

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

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

                    job();
                },
                Message::Terminate => {
                    println!("Worker {id} was told to terminate.");

                    break;
                },
            }
        });

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

我们原本的消息直接传递 Job,现在则改成传递 Message 枚举实体。Message 枚举有 NewJob 和 Terminate 两个变体,NewJob 变体可以让接收到该消息的线程去运行新的闭包;Terminate 变体可以让接收到该消息的线程跳出 loop 循环。在 ThreadPool 结构实体要被消灭之前,会先发送 Terminate 变体消息给其底下的所有 Worker 结构实体的线程,接着等待所有的线程都跳出 loop 循环并且运行完毕之后,ThreadPool 结构实体才会被消灭。

至于要如何触发 ThreadPool 结构实体的 drop 方法?首要步骤就是让 Incoming 迭代器的 for 循环能够停止运行,一旦 main 函数运行结束,属于该 scope 底下的拥有者所持有的值都会被消灭,包括 pool 变量所拥有的 ThreadPool 结构实体。我们可以让 Incoming 迭代器的 for 循环,在每次迭代时都去检查现在是否为正在关闭程序的状态,如果是的话就跳出循环。

程序修改如下:

use std::{
    io::{self, prelude::*, Read},
    net::{TcpListener, TcpStream},
    thread,
    time::Duration,
};

use hello_web::ThreadPool;

const PORT: i32 = 3000;
const WORKER_SIZE: usize = 8;

static mut CLOSING: bool = false;

fn main() {
    let listener = TcpListener::bind(format!("127.0.0.1:{PORT}")).unwrap();
    let pool = ThreadPool::new(WORKER_SIZE);

    thread::spawn(|| loop {
        let mut buffer = String::new();

        io::stdin().read_line(&mut buffer).unwrap();

        if buffer.trim().to_lowercase() == "exit" {
            unsafe {
                CLOSING = true;
            }

            println!("Server is closing.");

            if let Ok(mut stream) = TcpStream::connect(format!("127.0.0.1:{PORT}")) {
                if stream.write_all(b"exit").is_ok() && stream.flush().is_err() {
                    // do nothing
                }
            }

            break;
        }
    });

    for stream in listener.incoming() {
        unsafe {
            if CLOSING {
                break;
            }
        }

        let stream = stream.unwrap();

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

    println!("Server connection closed.");
}

fn handle_connection(mut stream: TcpStream) {
    let mut buffer = [0; 512];

    let c = stream.read(&mut buffer).unwrap();

    let request = String::from_utf8_lossy(&buffer[0..c]);

    let page404 = || {
        let content = "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Oops!</h1>
        <p>Sorry, I don't know what you're asking for.</p>
    </body>
</html>
";

        format!(
            "HTTP/1.1 404 NOT FOUND\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{content}",
            content.len()
        )
    };

    let page200 = |content: &str| {
        format!(
            "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{content}",
            content.len()
        )
    };

    let response = if request.starts_with("GET") {
        let request = &request["GET".len() + 1..];
        let path = &request[..request.find(' ').unwrap()];

        match path {
            "/" => page200(
                "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Hello!</h1>
        <p>Hi from Rust</p>
    </body>
</html>
",
            ),
            "/search" => {
                thread::sleep(Duration::from_secs(15));

                page200(
                    "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Search Result</h1>
        <p>Found nothing.</p>
    </body>
</html>
",
                )
            },
            _ => page404(),
        }
    } else {
        page404()
    };

    stream.write_all(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}

我们设置一个 CLOSING 全域静态变量来保存目前的程序状态是不是正在关闭中,预设为 false。并在 main 函数中,进入 for 循环之前,先创建了一个线程,从标准输入中取得用户输入的指令。当用户输入的指令为 exit 时,就会将 CLOSING 全域静态变量的值更改为 true。Incoming 迭代器的 for 循环中,在处理 HTTP 请求前,我们先去判断 CLOSING 全域静态变量的值是否为 true,如果是的话就直接跳出循环,结束程序。因此,当用户输入的指令为 exit 时,除了要将 CLOSING 全域静态变量的值更改为 true 之外,我们还必须要再使用 TcpStream 结构体,链接到我们的 HTTP Server,来触发 Incoming 迭代器的 for 循环进行下一次的迭代,程序才会去判断 CLOSING 全域静态变量的值是否为 true。

运行程序项目,随便使用浏览器快速打开数次 http://127.0.0.1:3000 网址和 http://127.0.0.1:3000/search 网址来试试,最后再从终端机输入 exit 来安全地结束程序。终端机结果如下:

输入 exit 安全结束 Web 服务器

由于我们使用到可变的静态变量,因此有使用 unsafe 关键字使部份程序进入不安全模式。如果想挑战不使用 unsafe 关键字的话,也可以使用消息传递的方式来完成同样的功能,只是性能可能会稍微差一点。可将程序改写如下:

use std::{
    io::{self, prelude::*, Read},
    net::{TcpListener, TcpStream},
    sync::mpsc,
    thread,
    time::Duration,
};

use hello_web::ThreadPool;

const PORT: i32 = 3000;
const WORKER_SIZE: usize = 8;

fn main() {
    let listener = TcpListener::bind(format!("127.0.0.1:{PORT}")).unwrap();
    let pool = ThreadPool::new(WORKER_SIZE);

    let (sender, receiver) = mpsc::channel();

    thread::spawn(move || loop {
        let mut buffer = String::new();

        io::stdin().read_line(&mut buffer).unwrap();

        if buffer.trim().to_lowercase() == "exit" {
            sender.send("exit").unwrap();

            println!("Server is closing.");

            if let Ok(mut stream) = TcpStream::connect(format!("127.0.0.1:{PORT}")) {
                if stream.write_all(b"exit").is_ok() && stream.flush().is_err() {
                    // do nothing
                }
            }

            break;
        }
    });

    for stream in listener.incoming() {
        if receiver.try_recv().is_ok() {
            break;
        }

        let stream = stream.unwrap();

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

    println!("Server connection closed.");
}

fn handle_connection(mut stream: TcpStream) {
    let mut buffer = [0; 512];

    let c = stream.read(&mut buffer).unwrap();

    let request = String::from_utf8_lossy(&buffer[0..c]);

    let page404 = || {
        let content = "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Oops!</h1>
        <p>Sorry, I don't know what you're asking for.</p>
    </body>
</html>
";

        format!(
            "HTTP/1.1 404 NOT FOUND\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{content}",
            content.len()
        )
    };

    let page200 = |content: &str| {
        format!(
            "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{content}",
            content.len()
        )
    };

    let response = if request.starts_with("GET") {
        let request = &request["GET".len() + 1..];
        let path = &request[..request.find(' ').unwrap()];

        match path {
            "/" => page200(
                "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Hello!</h1>
        <p>Hi from Rust</p>
    </body>
</html>
",
            ),
            "/search" => {
                thread::sleep(Duration::from_secs(15));

                page200(
                    "<!DOCTYPE html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\">
        <title>Hello!</title>
    </head>
    <body>
        <h1>Search Result</h1>
        <p>Found nothing.</p>
    </body>
</html>
",
                )
            },
            _ => page404(),
        }
    } else {
        page404()
    };

    stream.write_all(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}

结论

我们的多线程且可以被安全关闭的 Web 服务器程序到这里就已经实作完成啦!这个章节的内容只是前几个章节的应用,如果真的要使用 Rust 编程语言来开发 Web 服务器程序,建议还是直接在 crates.io 上寻找现成的 Web 应用框架和套件来使用,开发速度会快很多。

这个系列的文章就到这里为止了,Rust 编程语言不是一个容易上手的编程语言,尤其是拥有权和生命周期真的很难理解,毕竟它们是其它大部分的编程语言所没有的概念。不过,相信大家在使用 Rust 编程语言开发程序的时候都会注意到,虽然我们写的程序可能要按照编译器提示的消息修改好几次才能编译成功,但编译出来的程序几乎就已经没什么问题了,不太需要用什么调试工具来一行一行地查找代码哪边有 Bug 出现。

期望在未来,Rust 编程语言可以与更多领域作结合,像是完美搭配 WebAssembly,真正实现网站前后端都使用 Rust 编程语言来完成的架构。甚至是更深入底层,让单芯片微电脑(Microcontroller)的程序也能够使用 Rust 编程语言来撰写!

如果还想学习更多 Rust 编程语言的知识,请参考编程语言的 Rust 分类文章。