Start a background task

[kzhui125]

Hello, I want to start a background task that runs forever, for example, write to a file for every 2 seconds.

I want to know which method is better, use tokio::spawn or std::thread::spawn?

method 1:

#[tokio::main]
async fn main() {
    let (tx, mut rx) = oneshot::channel();

    let t_handle = tokio::spawn(async move {
        let mut interval = interval(Duration::from_secs(2));
        let mut file = OpenOptions::new()
            .append(true)
            .create(true)
            .open("foo.txt")
            .await
            .unwrap();
        let mut i = 0;
        loop {
            tokio::select! {
                _ = interval.tick() => {
                    i += 1;
                    file.write(format!("hello{i}\n").as_bytes()).await.unwrap();
                },
                _ = &mut rx => {
                    file.flush().await.unwrap();
                    break;
                }
            }
        }
    });

    start_server().await;
    tx.send(true).unwrap(); // signal to exit
    t_handle.await.unwrap();
}

method2:

#[tokio::main]
async fn main() {
    let (tx, mut rx) = oneshot::channel();

    let handle = Handle::current();
    let t_handle = std::thread::spawn(move || {
        handle.block_on(async {
            let mut interval = interval(Duration::from_secs(2));
            let mut file = OpenOptions::new()
                .append(true)
                .create(true)
                .open("foo.txt")
                .await
                .unwrap();
            let mut i = 0;
            loop {
                tokio::select! {
                    _ = interval.tick() => {
                        i += 1;
                        file.write(format!("hello{i}\n").as_bytes()).await.unwrap();
                    },
                    _ = &mut rx => {
                        file.flush().await.unwrap();
                        break;
                    }
                }
            }
        });
    });

    start_server().await;
    tx.send(true).unwrap(); // signal to exit
    t_handle.join().unwrap();
}

And what about method2 with handle of Runtime::new() instead of handle of current?

Thanks a lot,