线程不是并行运行的

Question

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

我怎么能去做这个异步？

extern crate hyper;
extern crate time;

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

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所说,这可能允许主线程在产生的线程退出之前退出.这会导致所有生成的线程被杀死,而不是让它们运行终止.