advance-practice1/graceful-shutdown

[giscus[bot]]

advance-practice1/graceful-shutdown

https://course.rs/advance-practice1/graceful-shutdown.html

[xgfone]

对于 while let Ok(job) = receiver.lock().unwrap().recv() 还是不是很理解：

在 receiver.lock().unwrap().recv() 中，对于 .recv() 而言，其前面 receiver.lock().unwrap() 的返回值不是临时变量吗？当调用完 recv() 后，不应该就消失了吗（recv()调用完后没有谁再使用它了）？

let job = receiver.lock().unwrap().recv().unwrap(); 在这行代码中，由于使用了 let，右边的任何临时变量会在 let 语句结束后立即被 drop，因此锁会自动释放

如果按这句话的解释，那是否是说：单独使用 let 就会消失，而在 while let 中就不会消失？？如果是这样，那也太扯蛋了！

[xgfone]

那这样的话，while let 就是 match 的一个语法粮：Rust 在编译时会把 while let 语句变成 match 语句。

对于语言是如何实现的，使用者并不是太关心；站在语法使用的角度，while let 和 let 差别那么大就有点理解。感觉这个和 NLL 没实现前的麻烦一样。

[JMILI]

我的理解是这样的 let 是一个语句，可以把他看做一个语句块，他接受消息之后，就释放了右边任何临时变量了。不需要他们了，因为我已经收到自己想要的数据了。
while let 是一直接收数据，而且job()放在了while 里面，这样相当于while 的作用域还没完就要处理任务，同时后面可能还要接收数据，所以不能释放receiver.lock().unwrap().recv() 这个资源，这样的话就等于还是排队处理请求。
不知道理解的对不对？

[lp956]

我理解let 跟while let 的作用域不一样，let 的作用域就是分号，while let 的作用域变成了while最后的 }

[xgfone]

这篇文章来源于《The Rust Programming Language》中的第 20.2 章节《Turning Our Single-Threaded Server into a Multithreaded Server》，直接看官方文档，说的很明白了：

The code in Listing 20-20 that uses let job = receiver.lock().unwrap().recv().unwrap(); works because with let, any temporary values used in the expression on the right hand side of the equals sign are immediately dropped when the let statement ends. However, while let (and if let and match) does not drop temporary values until the end of the associated block. In Listing 20-21, the lock remains held for the duration of the call to job(), meaning other workers cannot receive jobs.

中文：

示例 20-20 中的代码使用的 let job = receiver.lock().unwrap().recv().unwrap(); 之所以可以工作是因为对于 let 来说，当 let 语句结束时任何表达式中等号右侧使用的临时值都会立即被丢弃。然而 while let（if let 和 match）直到相关的代码块结束都不会丢弃临时值。在示例 20-21 中，job() 调用期间锁一直持续，这也意味着其他的 worker 无法接受任务。

总结：单独使用 let 声明一个变量，它会丢弃等号右边除最后一个值外的其它所有的临时变量；而对于 if let、while let 或 match，只有当它的整个作用域结束时，才会丢弃等号右边除最后一个值外的其它所有的临时变量。

如果要用一个终极规则或语法来说的话，就是：无论是 let，还是 if let、while let 、match，只是在它的作用域结束时，才会丢弃等号右边除最后一个值外的其它所有的临时变量。而对于 let 来说，它并不开启一个子作用域，而是使用它所在的作用域范围；对于 if let、while let 、match，它们会开启一个新的子作用域，所以要等到子作用域结束。

[limuyao1996]

其实最实用的方式就是使用完后，立马手动 drop(receiver)，就不会受到语言本身特性的影响了

[Luv-Ray]

将for worker in &mut self.workers换成for worker in self.workers.drain(..)就能逐个取走所有权吧

[Luv-Ray]

另外还有个疑问，在main.rs中不使用for stream in listener.incoming().take(2)的话，如何正常关闭服务器？有其他办法中断incoming()吗？

[Jorrrmungandr]

我也觉得很奇怪, 只给了一段测试停机的代码, 根本不可用啊

[araraloren]

可以捕获CTRL + C产生的信号，然后在信号处理函数里

let listener = TcpListener::bind("0.0.0.0:17979")?;
let localaddr = listener.local_addr()?;
let pool = ThreadPool::new(4);
let shutdown = Arc::new(AtomicBool::new(false));
let shutdown_clone = Arc::clone(&shutdown);

ctrlc::set_handler(move || {
    shutdown_clone.store(true, std::sync::atomic::Ordering::Relaxed);
    println!("Got ctrl c signal");
    let _ = TcpStream::connect(localaddr);
})?;

for stream in listener.incoming() {
    if !shutdown.load(std::sync::atomic::Ordering::Relaxed) {
        let stream = stream.unwrap();

        pool.execute(|| {
            handle_connection(stream).unwrap();
        })?;
    } else {
        break;
    }
}
Ok(())

[Buer-Nahida]

你这有点多此亿举，只需要把线程池drop掉然后用process::exit(0)终止程序就行了:
(需要ctrlc和console库)

static mut THREAD_POOL: Option<ThreadPool> = None;

fn main() -> Result<(), Box<dyn Error>> {
    println!("{} Starting...", style("[MAIN]:").green());
    println!("{} Listening 127.0.0.1:19198...", style("[MAIN]:").green(),);
    let listener = Arc::new(TcpListener::bind("127.0.0.1:19198").unwrap_or_else(|err| {
        println!("{} {}", style("Failed to bind 127.0.0.1:19198:").red(), err);
        process::exit(err.raw_os_error().unwrap_or(1));
    }));

    println!("{} Initializing thread pool...", style("[MAIN]:").green());
    unsafe { THREAD_POOL = Some(ThreadPool::new(6)) };
    ctrlc::set_handler(move || {
        println!(
            "{} {}",
            style("\n[MAIN]:").green(),
            style("Received SIGINT, shutting down...").red()
        );
        unsafe { THREAD_POOL.take() };
        process::exit(0);
    })?;

    println!("{}", style("[MAIN]: Finished start").green());
    for stream in listener.incoming() {
        let stream = stream?;
        unsafe { THREAD_POOL.as_ref() }.unwrap().execute(|| {
            handle_connection(stream);
        })
    }

    Ok(())
}

[YXHXianYu]

将for worker in &mut self.workers换成for worker in self.workers.drain(..)就能逐个取走所有权吧

我也想到了一种方法，用while let和pop()，也可以一个一个取走所有权：

while let Some(worker) = self.workers.pop() {
    worker.join();
};

[TsGanT]

这里没有看的很懂，意思是使用as_ref就可以把Option里的值取出来，然后unwarp看是否是none，不是的话就调用Option中mpsc::Sender的send方法吗？但是为啥as_ref就可以把Option里的值取出来呢？

self.sender.as_ref().unwrap().send(j).unwrap()

[TsGanT]

奥 我好像知道了

// as_ref 在此处主要是需要获得Option中内容的借用权
// unwrap 是获得借用权后直接取Option中的值
// send(j) 是根据execute输入的值，来初始化 ThreadPool 中的 mpsc::Sender<Job> 任务
// unwrap是执行 mpsc::Sender 的send函数；
let _ = self.sender.as_ref().unwrap().send(j).unwrap();

[Jorrrmungandr]

我运行了这段代码, 发现发送两个请求之后程序并不会停止, 最后一个worker线程似乎还在阻塞, 再发一个请求才会终止, 这是为什么呢

[canxin121]

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

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

main中的此处 take(2)表示只接受两个(次)请求, 然后break, for就结束了,之后就会自动Drop了

[canxin121]

然后drop里面

            if let Some(thread) = worker.thread.take() {
                thread.join().unwrap();
            }

在thread.join的时候,如果你是请求的/sleep, 程序会sleep(5)秒之后, join才会结束,Drop才被调用完成. 可能是 你在这5秒里面又请求了第三次, 但是实际上是5秒结束drop结束, 不是再发一次请求结束的. 你可以再试试

[LittleDonkeyYang]

作者你好，我把你的源码复制粘贴执行；先访问/slepp，在访问其它接口会阻塞（变成了单线程）；请问是不是代码不完整啊