advance/async/web-server

[giscus[bot]]

advance/async/web-server

https://course.rs/advance/async/web-server.html

[lqygbzy]

为什么我把依赖加上后总是build失败😥😥😥

[mxismean]

使用多线程并行处理请求:

同时发起多个 /sleep 请求， 第一个5s后返回，第二个 10s后返回，第三个15s后返回， 貌似并没有与多个线程同时处理这些请求吧？

[mxismean]

使用的是 task 中的 sleep， 代码如下：

use async_std::net::TcpListener;
use async_std::net::TcpStream;
use async_std::prelude::*;
use async_std::task::{self, spawn};
use futures::stream::StreamExt;
use std::{fs, time::Duration};

#[async_std::main]
async fn main() {
  let listener = TcpListener::bind("127.0.0.1:7878").await.unwrap();
  listener
    .incoming()
    .for_each_concurrent(None, |tcpstream| async move {
      let tcpstream = tcpstream.unwrap();
      spawn(handle_connection(tcpstream));
    })
    .await;
}

async fn handle_connection(mut stream: TcpStream) {
  let mut buffer = [0; 1024];
  stream.read(&mut buffer).await.unwrap();
  let get = b"GET / HTTP/1.1\r\n";
  let sleep = b"GET /sleep HTTP/1.1\r\n";
  let (status_line, filename) = if buffer.starts_with(get) {
    ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
  } else if buffer.starts_with(sleep) {
    task::sleep(Duration::from_secs(5)).await;
    ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
  } else {
    ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
  };
  let contents = fs::read_to_string(filename).unwrap();
  let response = format!("{status_line}{contents}");
  stream.write(response.as_bytes()).await.unwrap();
  stream.flush().await.unwrap();
}

[makisevon]

我猜你是用 Chrome 测试的？Chrome 默认使用的缓存策略限制了对同一个 URL 的并发请求，建议使用 cURL 或 Postman 等工具测试。

[mxismean]

是的，的确用的chrome， 感谢感谢🙏

[Yougigun]

記得可以把chrom devtool 打開，這個限制也會被取消

[PigsyAK]

测试结果：

1. 没有异步：同一个浏览器中
2. 没有异步：curl -Z http://127.0.0.1:7878/sleep http://127.0.0.1:7878/sleep http://127.0.0.1:7878/sleep
3. 异步：edge + chrome，edge + curl

感觉是tcp流这里阻塞了，然后浏览器不同标签页或者curl -Z的请求复用了一个tcp流。不懂，瞎猜的，希望有大佬能讲通透。

[zhangdekui]

单线程异步确实神奇
listener是异步的,
handle也是异步的,
下面的sleep也是异步,
任意一个io事件发生的时候都会切换到具有异步标记的地方,
所以第一个请求异步sleep过程中, 第二个请求进来时, 异步的listener得以运行,
第二个请求运行到异步sleep时, 当第一个请求的sleep结束时, 立马又能切换过来,
看起来像是并行, 其实是并发, 切换的比较快而已.

[ranqiwei]

单线程异步模拟并行的感觉

[lgln0]

多线程+async，

spawn(handle_connection(stream));

这不是为每个async开了个线程吗，那async还有什么意义？我的理解是async类似协程，把当前线程分成一个个task，可在task间无缝切换，但task阻塞则线程阻塞。但如果每个线程里只有一个async，不等于没async吗？

[Alkaidd]

我感觉这里的例子多线程+异步确实没什么意义。但是如果你把sleep看成另一个异步任务应该就可以理解了。

[Initsnow]

这里spawn的应该是一个类似Task的东西而不是线程

[sleep-bit]

因为这里async_std的spawn函数和thread中所用的spawn函数是不一样的，前者是创建任务并将该异步任务提交到任务队列通过异步运行时来进行任务调配的，他所使用的线程数是异步运行时设定的线程池大小，后者是会创建操作系统中的线程。

[learnerLj]

tokio 版本：

use futures::stream::StreamExt;
use tokio::fs;
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader}; // Use tokio::io::BufReader, AsyncBufReadExt, and AsyncWriteExt
use tokio::net::{TcpListener, TcpStream};
use tokio_stream::wrappers::TcpListenerStream;
#[tokio::main]
async fn main() {
    let listener = TcpListener::bind("127.0.0.1:8878").await.unwrap();
    TcpListenerStream::new(listener)
        .for_each_concurrent(None, |stream_result| async {
            match stream_result {
                Ok(stream) => {
                    handle_connection(stream).await;
                }
                Err(e) => eprintln!("Connection error: {}", e),
            }
        })
        .await;
}

async fn handle_connection(mut stream: TcpStream) {
    let buf_reader = BufReader::new(&mut stream);
    let mut lines = buf_reader.lines();
    let request_line = lines.next_line().await.unwrap().unwrap();
    let (status_line, filename) = if request_line == "GET / HTTP/1.1" {
        ("HTTP/1.1 200 OK", "hello.html")
    } else {
        ("HTTP/1.1 404 NOT FOUND", "404.html")
    };

    let contents = fs::read_to_string(filename).await.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()).await.unwrap();
}

cargo.toml

[package]
name = "hello"
version = "0.1.0"
edition = "2024"

[dependencies]
futures = "0.3"
tokio = { version = "1", features = ["full"] }
tokio-stream = { version = "0.1", features = ["net"] }