Is there any way to send Function objects across threads?

[calops]

I have a struct that needs to contain some lua callback functions. That struct represents a global state defined in a lazy_static, behind a RwLock. I've tried it with both std::sync::RwLock and parking_lot::RwLock (with the adequate feature flag enabled), but I keep getting the same errors:

error[E0277]: `*mut lua_State` cannot be shared between threads safely
   --> src/libs/structs/config.rs:10:1
    |
10  | / lazy_static! {
11  | |     pub static ref CONFIG: Arc<Config> = Arc::new(Config::default());
12  | | }
    | |_^ `*mut lua_State` cannot be shared between threads safely
    |
    = help: within `mlua::lua::LuaInner`, the trait `Sync` is not implemented for `*mut lua_State`
    = note: consider using `std::sync::Arc<*mut lua_State>`; for more information visit <https://doc.rust-lang.org/book/ch16-03-shared-state.html>
note: required because it appears within the type `LuaInner`
   --> /home/calops/.cargo/registry/src/index.crates.io-6f17d22bba15001f/mlua-0.9.0/src/lua.rs:73:12
    |
73  | pub struct LuaInner {
    |            ^^^^^^^^
    = note: required for `std::sync::Arc<mlua::lua::LuaInner>` to implement `Sync`
note: required because it appears within the type `Lua`
   --> /home/calops/.cargo/registry/src/index.crates.io-6f17d22bba15001f/mlua-0.9.0/src/lua.rs:70:12
    |
70  | pub struct Lua(Arc<LuaInner>);
    |            ^^^
    = note: required for `&'static Lua` to implement `std::marker::Send`
note: required because it appears within the type `LuaRef<'static>`
   --> /home/calops/.cargo/registry/src/index.crates.io-6f17d22bba15001f/mlua-0.9.0/src/types.rs:270:19
    |
270 | pub(crate) struct LuaRef<'lua> {
    |                   ^^^^^^
note: required because it appears within the type `Function<'static>`
   --> /home/calops/.cargo/registry/src/index.crates.io-6f17d22bba15001f/mlua-0.9.0/src/function.rs:26:12
    |
26  | pub struct Function<'lua>(pub(crate) LuaRef<'lua>);
    |            ^^^^^^^^
note: required because it appears within the type `Keybinding`
   --> src/libs/structs/config.rs:91:12
    |
91  | pub struct Keybinding {
    |            ^^^^^^^^^^
    = note: required for `Unique<Keybinding>` to implement `std::marker::Send`
note: required because it appears within the type `RawVec<Keybinding>`
   --> /rustc/180dffba142c47240ca0d93096ce90b9fd97c8d7/library/alloc/src/raw_vec.rs:51:19
note: required because it appears within the type `Vec<Keybinding>`
   --> /rustc/180dffba142c47240ca0d93096ce90b9fd97c8d7/library/alloc/src/vec/mod.rs:396:12
    = note: required for `parking_lot::lock_api::RwLock<parking_lot::RawRwLock, Vec<Keybinding>>` to implement `Sync`
note: required because it appears within the type `Config`
   --> src/libs/structs/config.rs:109:12
    |
109 | pub struct Config {
    |            ^^^^^^
    = note: required for `std::sync::Arc<Config>` to implement `Sync`
note: required by a bound in `lazy_static::lazy::Lazy`
   --> /home/calops/.cargo/registry/src/index.crates.io-6f17d22bba15001f/lazy_static-1.4.0/src/inline_lazy.rs:19:20
    |
19  | pub struct Lazy<T: Sync>(Cell<Option<T>>, Once);
    |                    ^^^^ required by this bound in `Lazy`
    = note: this error originates in the macro `__lazy_static_create` which comes from the expansion of the macro `lazy_static` (in Nightly builds, run with -Z macro-backtrace for more info)

Is this an issue specific to lazy_static? Is there a way to accomplish what I want? And yes, I do have the send feature flag enabled.

[khvzak]

You need to make Lua global, protected by mutex and then store references to Lua objects (functions/tables/etc) in the registry, accessible via RegistryKey.

RegistryKey itself is Send + Sync so it's safe to store it anywhere.

static LUA: Lazy<parking_lot::Mutex<Lua>> = Lazy::new(|| parking_lot::Mutex::new(Lua::new()));

struct MyStruct {
    func: RegistryKey,
}

fn main() -> Result<()> {
    // To create
    let my_struct = {
        let lua = LUA.lock();
        let func = lua.create_function(|_, ()| {
            println!("hello");
            Ok(())
        })?;
        MyStruct {
            func: lua.create_registry_value(func)?,
        }
    };

    // To call
    {
        let lua = LUA.lock();
        let func = lua.registry_value::<Function>(&my_struct.func)?;
        func.call(())?;
    }

    Ok(())
}

[calops]

Oh, I see, that makes sense, thanks! However it seems to work with parking_lot::Mutex but not parking_lot::RwLock, is there a reason for this? Although I'm not sure an RwLock makes sense in the first place here.

[khvzak]

RwLock implements Sync only for T: Send + Sync, whereas Mutex implements Sync for T: Send.

It's (rwlock) now usefull in case of Lua actually. You can use ReentrantMutex to double lock Lua within the same thread.

[jjeffcaii]

It seems doesn't work, here's my codes (withmlua = { version = "0.9.1", features = ["luau-jit", "vendored", "serialize", "async", "macros"] }):

use mlua::{Function, Lua, RegistryKey};
use once_cell::sync::Lazy;

static LUA: Lazy<parking_lot::Mutex<Lua>> = Lazy::new(|| parking_lot::Mutex::new(Lua::new()));

struct MyStruct {
    func: RegistryKey,
}

fn main() -> anyhow::Result<()> {
    // To create
    let my_struct = {
        let lua = LUA.lock();
        let func = lua.create_function(|_, ()| {
            println!("hello");
            Ok(())
        })?;
        MyStruct {
            func: lua.create_registry_value(func)?,
        }
    };

    // To call
    {
        let lua = LUA.lock();
        let func = lua.registry_value::<Function>(&my_struct.func)?;
        func.call(())?;
    }

    Ok(())
}

The error message:

[khvzak]

@jjeffcaii seems you forgot to add send feature to mlua.

[jjeffcaii]

It works after adding send feature. Thanks! ❤️