'a in spawn_blocking

[xuxiaocheng0201]

In many cases, the task is not 'static, but the params is 'a, so I have to clone the param to make the task 'static.
For example:

async fn hash(content: &str) -> anyhow::Result<String> {
    let content = content.to_string();
    tokio::task::spawn_blocking(move || util::hash::sha256::digest(&content)).await?
}

Is there any way to avoid clone the content?
I joined the future immediately so I think the task is not necessary to be 'static.
For some reasons, I don't want to use Arc, because the content may be zero-copied from other vec.

[wathenjiang]

You might use block on or run_util of the LocalSet. See https://tikv.github.io/doc/tokio/task/struct.LocalSet.html

[xuxiaocheng0201]

Thank for your suggestion.
But LocalSet::block_on is for !Send futures, it blocks on the current thread.
In my case, the task is Send. I want to send the task to the blocking thread to avoid blocking the current thread, just like spawn_blocking.

[Darksonn]

It's not possible. You'll have to clone the data.

[xuxiaocheng0201]

It's not possible. You'll have to clone the data.

@Darksonn Oh that's bad. Is there any plan to support this situation?

[Darksonn]

It's a limitation that has to be fixed in the language. There is nothing Tokio can do until the language changes. You can read more about why in this article: The scoped task trilemma

[xuxiaocheng0201]

Can tokio::task::blocking be considered a compromise solution?

[Darksonn]

What do you mean?

[xuxiaocheng0201]

Oh sorry, I copied it incorrectly. What I mean is tokio::task::block_in_place.

[Darksonn]

It has a whole bunch of disadvantages such as:

1. Doesn't work in current-thread runtime.
2. Blocks other work in same task (e.g. via tokio::join! or FuturesUnordered).
3. May lead to running out worker threads, since it can only spawn new worker threads until the spawn_blocking pool limit.
   So it's not a great alternative.

[xuxiaocheng0201]

Why unsafe code like this cannot be used?

use tokio::task::{JoinError, spawn_blocking};

pub async fn spawn_blocking_local<R: Send + 'static, F: FnOnce() -> R + Send>(local: F) -> Result<R, JoinError> {
    let raw = Box::into_raw(Box::new(local)) as usize;
    spawn_blocking(move || {
        let func = *unsafe { Box::from_raw(raw as *mut F) };
        func()
    }).await
}

I tested and no problem.

#[tokio::main]
async fn main() -> Result<()> {
    let mutex = Mutex::new(123);
    let borrow = mutex.lock().await;
    let local = move || { println!("{}", &borrow) };
    spawn_blocking_local(local).await?;
    Ok(())
}

@Darksonn I'm sorry to bother you again, but I really want to know the reason.

[Darksonn]

Because of cancellation. Consider this example, where a string is used after it is freed.