What is the correct way in Rust to create a timeout for a thread or a function?

Question

This is my code:

use std::net;
use std::thread;

fn scan_port(host: &str, port: u16) -> bool {
    let host = host.to_string();
    let port = port;
    let t = thread::spawn(move || net::TcpStream::connect((host.as_str(), port)).is_ok());

    t.join().unwrap()
}

How do I create a situation where the thread will be terminated or killed if the connection didn't finish in N seconds?

The reason for all of this is that Rust has no way to set a socket connection timeout so I have no way to ensure the program won't get stuck.

It would probably be better if your sample code was more minimal, showing only the problem at hand instead of a page of command line argument parsing and option fiddling. — Mike Cooper, Mar 23 '16 at 15:09
Terminating or killing a thread was a [bad](http://stackoverflow.com/q/5218969/155423) [idea](http://stackoverflow.com/q/1559255/155423) in the languages that added it. Rust won't be adding it. — Shepmaster, Mar 23 '16 at 15:13
@Ba7a7chy: I think @MikeCooper meant an [MCVE](http://stackoverflow.com/help/mcve), meaning something that doesn't even relate to tcp. Just a thread that does `loop {}` and your attempts at killing it. — oli_obk, Mar 23 '16 at 15:21
@ker I have some hopes that maybe someone would see this example in Rust and will say "oh, you can't set timeout but you can do x" so I'll leave the specific tcp socket example in the hope of this will come true :) — Ba7a7chy, Mar 23 '16 at 15:28
oh right, that makes sense. Still, the `argparse` crate import is not necessary — oli_obk, Mar 23 '16 at 15:31
The [`net2`](https://doc.rust-lang.org/net2-rs/net2/index.html) crate gives you more finegrained control for the tcp-case according to [alexcrichton](https://github.com/rust-lang/rust/issues/31724#issuecomment-185298027) — oli_obk, Mar 23 '16 at 15:35

oli_obk · Answer 1 · 2016-03-23T15:46:01.667

As @Shepmaster noted: it's a bad idea to terminate threads.

What you can do instead is to give the thread a Sender through which it should notify you if it has successfully opened a connection (maybe even by sending you the handle). Then you can let your main thread sleep for the time you wish to wait. When your thread wakes up, it checks its corresponding Receiver for some sign of life from the thread. In case the thread did not answer, just release it into the wild by dropping the JoinHandle and the Receiver. It's not like it's consuming cpu-time (it's blocked), and it's not consuming too much memory. If it ever unblocks, it'll detect that the Sender is not connected and can shut down for good.

Of course you should not have bazillions of these open threads, because they still use resources (memory and system thread handles), but on a normal system that's not too much of an issue.

Example:

use std::net;
use std::thread;
use std::sync::mpsc;

fn scan_port(host: &str, port: u16) -> bool {
    let host = host.to_string();
    let port = port;
    let (sender, receiver) = mpsc::channel();
    let t = thread::spawn(move || {
        match sender.send(net::TcpStream::connect((host.as_str(), port))) {
            Ok(()) => {}, // everything good
            Err(_) => {}, // we have been released, don't panic
        }
    });

    thread::sleep(std::time::Duration::new(5, 0));

    match receiver.try_recv() {
        Ok(Ok(handle)) => true, // we have a connection
        Ok(Err(_)) => false, // connecting failed
        Err(mpsc::TryRecvError::Empty) => {
            drop(receiver);
            drop(t);
            // connecting took more than 5 seconds
            false
        },
        Err(mpsc::TryRecvError::Disconnected) => unreachable!(),
    }
}

I tried that now, it seems that Receiver blocks until it gets an answer, if that is really the case I'm in the same place when using Send\Receive — Ba7a7chy, Mar 23 '16 at 15:43
I updated with some code. You need to use `try_recv`, which is the non-blocking receiving method — oli_obk, Mar 23 '16 at 15:46

score 11 · Accepted Answer · answered Mar 10 '17 at 14:15

The answer by @ker will always wait 5 seconds, even if the connection finishes more quickly. Here is a similar approach where the timeout and network request both happen on separate threads, and the first one finished wins:

let (sender, receiver) = mpsc::channel();
let tsender = sender.clone();
let t = thread::spawn(move || {
    match sender.send(Ok(net::TcpStream::connect((host.as_str(), port)))) {
        Ok(()) => {}, // everything good
        Err(_) => {}, // we have been released, don't panic
    }
});
let timer = thread::spawn(move || {
  thread::sleep(Duration::from_millis(5000));
  match tsender.send(Err(MyTimeoutError)) {
    Ok(()) => {}, // oops, we timed out
    Err(_) => {}, // great, the request finished already
  }
});
return receiver.recv().unwrap();

But as long as you're doing that, you might as well just use recv_timeout instead:

let (sender, receiver) = mpsc::channel();
let t = thread::spawn(move || {
    match sender.send(net::TcpStream::connect((host.as_str(), port))) {
        Ok(()) => {}, // everything good
        Err(_) => {}, // we have been released, don't panic
    }
});
return receiver.recv_timeout(Duration::from_millis(5000));

score 3 · Answer 3 · answered Oct 28 '22 at 10:47

Here is an abstraction so you can run any function with a timeout

use std::{
    collections::HashMap,
    sync::mpsc::{self, RecvTimeoutError},
    thread,
    time::Duration,
};

#[derive(Debug)]
struct TimeoutError;

fn run_with_timeout<F, T>(f: F, timeout: Duration) -> Result<T, TimeoutError>
where
    F: FnOnce() -> T + Send + 'static,
    T: Send + 'static,
{
    let (tx, rx) = mpsc::channel();
    let _ = thread::spawn(move || {
        let result = f();
        match tx.send(result) {
            Ok(()) => {} // everything good
            Err(_) => {} // we have been released, don't panic
        }
    });

    match rx.recv_timeout(timeout) {
        Ok(result) => Ok(result),
        Err(RecvTimeoutError::Timeout) => Err(TimeoutError),
        Err(RecvTimeoutError::Disconnected) => unreachable!(),
    }
}

#[allow(dead_code)]
#[derive(Debug)]
struct Foo {
    bar: String,
    bar_vec: Vec<String>,
    bar_map: HashMap<String, String>,
}

fn return_foo() -> Foo {
    Foo {
        bar: "bar".to_string(),
        bar_vec: vec!["bar".to_string()],
        bar_map: [("bar".to_string(), "bar".to_string())]
            .iter()
            .cloned()
            .collect(),
    }
}

fn main() {
    // This will timeout
    let result = run_with_timeout(
        || {
            thread::sleep(Duration::from_secs(2));
            42
        },
        Duration::from_secs(1),
    );
    println!("Result: {:?}", result);

    // This will not timeout
    let result = run_with_timeout(
        || {
            thread::sleep(Duration::from_secs(2));
            42
        },
        Duration::from_secs(3),
    );
    println!("Result: {:?}", result);

    // This will timeout (Custom type)
    let result = run_with_timeout(
        || {
            thread::sleep(Duration::from_secs(2));
            return_foo()
        },
        Duration::from_secs(1),
    );
    println!("Result: {:?}", result);

    // This will not timeout (Custom type)
    let result = run_with_timeout(
        || {
            thread::sleep(Duration::from_secs(2));
            return_foo()
        },
        Duration::from_secs(3),
    );
    println!("Result: {:?}", result);
}

Please note that the timeout will not stop the running thread. If you want to cancel the job use tokio. an example can be found here: https://github.com/JadKHaddad/Run-With-Timeout — Jad Haddad, Dec 13 '22 at 15:09

score 1 · Answer 4 · answered Feb 03 '23 at 09:41

You may use tokio.

use std::net;
use std::time::Duration;
use tokio::time::error::Elapsed;

async fn scan_port(host: &str, port: u16) -> Result<bool, Elapsed> {
    tokio::time::timeout(Duration::from_secs(10), async {
        net::TcpStream::connect((host, port)).is_ok()
    })
    .await
}

What is the correct way in Rust to create a timeout for a thread or a function?

4 Answers4

Linked