Question

考虑以下代码，我希望启动x个线程，它会在代码中向指定服务器发出x请求，但是在当前，我的应用程序正在等待每个线程和x请求完成，然后再启动下一个之一。

我该怎么做这个异步？

extern crate hyper;
extern crate time;

use hyper::Client;
use hyper::header::Connection;
use time::*;
use std::thread;
use std::sync::{Arc, Mutex};

struct Request {
    elapsed_time: f64
}

impl Request{
    fn new(elapsed_time: f64) -> Request{
        Request {
            elapsed_time: elapsed_time,
        }
    }
}

fn main() {
    let requests = Arc::new(Mutex::new(Vec::new()));

    for _x in 0..100 {
        println!("Spinning up thread...");

        let mut client = Client::new();
        let thread_items = requests.clone();

        let handle = thread::spawn(move || {
            for _x in 0..100 {
                println!("Firing the request");
                let start = time::precise_time_s();

                let _res = client.get("http://jacob.uk.com")
                    .header(Connection::close()) 
                    .send().unwrap();

                let end = time::precise_time_s();

                thread_items.lock().unwrap().push((Request::new(end-start)));
            }
        });

        handle.join().unwrap();
    }
}

节目输出：

Spinning up thread...
Firing request
Firing request
Firing request
Firing request
Spinning up thread...
Firing request
Firing request
Firing request
Firing request
Spinning up thread...
Firing request
Firing request
Firing request
Firing request

Answer 1

你的罪魁祸首是这一行：

handle.join().unwrap();

你在循环中执行一个线程，然后在启动线程后立即join进入主线程。

你可以做的是创建一个Vec并将所有句柄放在vec中。然后，在另一个循环中，您join所有句柄。

另一种可能性就是不加入线程，让它们自然退出，但是你不知道什么时候完成它们。正如@delnan所说，这可能允许主线程在产生的线程退出之前退出。这会导致所有生成的线程被杀死，而不是让它们运行终止。

线程不是并行运行的

1 个答案: