How to run a server in a thread？

[John-Chan]

Summary

I saw an example of this from actix-web: run-in-thread

How to do it use axum?

axum version

0.7.3

[davidpdrsn]

The easiest way is just to spawn a new async task with tokio::spawn:

use std::time::Duration;

use axum::{routing::get, Router};
use tower_http::timeout::TimeoutLayer;

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/", get(|| async { "Hello, World!" }))
        .layer(TimeoutLayer::new(Duration::from_secs(10)));

    let (close_tx, close_rx) = tokio::sync::oneshot::channel();

    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();
    let server_handle = tokio::spawn(async {
        axum::serve(listener, app)
            .with_graceful_shutdown(async move {
                _ = close_rx.await;
            })
            .await
            .unwrap();
    });

    println!("waiting 5 seconds");
    tokio::time::sleep(Duration::from_secs(5)).await;

    println!("telling server to shutdown");
    _ = close_tx.send(());

    println!("waiting for server to gracefully shutdown");
    _ = server_handle.await;
}

Assuming you're using tokio's multi-threaded scheduler, which is the default, then tokio will schedule things across threads. This is what I'd recommend.

You can also run axum on a dedicated thread using a single threaded tokio runtime:

use std::time::Duration;

use axum::{routing::get, Router};
use tower_http::timeout::TimeoutLayer;

fn main() {
    let (close_tx, close_rx) = tokio::sync::oneshot::channel();

    let server_handle = std::thread::spawn(|| run_server(close_rx));

    println!("waiting 5 seconds");
    std::thread::sleep(Duration::from_secs(5));

    println!("telling server to shutdown");
    _ = close_tx.send(());

    println!("waiting for server to gracefully shutdown");
    _ = server_handle.join();
}

fn run_server(close_rx: tokio::sync::oneshot::Receiver<()>) {
    let app = Router::new()
        .route("/", get(|| async { "Hello, World!" }))
        .layer(TimeoutLayer::new(Duration::from_secs(10)));

    let rt = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .unwrap();
    rt.block_on(async move {
        let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
            .await
            .unwrap();
        axum::serve(listener, app)
            .with_graceful_shutdown(async move {
                _ = close_rx.await;
            })
            .await
            .unwrap();
    });
}

[danbachar]

I'm having a similar problem, but I have a hybrid situation: I want to run axum on a blocking dedicated thread using tokio's task::spawn_blocking, and I have other tasks which I run with spawn. I want the tasks spawned using the normal spawn to run on a thread which is not the same thread as the axum http task, because the http task is IO-heavy and executes a number of syscalls. Before I refactored the code to spawn the http task as blocking, the http task would sometimes be scheduled on the same thread as the other tasks, which would cause them to hang until the http task is done answering an HTTP request.

My problem is that currently the HTTP task does not respond to HTTP requests (http requests hang).
Does anyone have a clue why it's happening?
My setup is as following:

// spawn a thread to process http requests
let http_task = {
    tokio::task::spawn_blocking(move || {
        axum::serve(listener, create_routes().with_state(multithread_config))
    })
};

// spawn a task to receive new stuff
let receive_new_stuff_task = {
    tokio::spawn(async move {
        loop {
            let something = new_receiver.recv().await.unwrap();
            // do something with something
        }
    })
};

// spawn a task to receive delete requests for things
let delete_stuff_task = {
    tokio::spawn(async move {
        loop {
            let id = delete_receiver.recv().await.unwrap();
            // delete thing with id
        }
    })
};

_ = terminate_receiver.recv().await;
http_task.abort();
delete_stuff_task.abort();
receive_new_stuff_task.abort();

[jplatte]

Please open a new discussion for your question.

[danbachar]

done