How can I run a struct‘s method in tokio::spawn?

[fakecore]

I want to use a struct to manage connected TcpStream.
e.g.

tokio::spawn(
                async move {
                    let mut ctx = Context::new(socket);
                    let mut service = NetService::new(&mut ctx);
                    service.handle_connected();
                    service.run().await;
                    service.handle_disconnected();
                }
            );

It failed to pass the compile, How do I modify the code to pass the compiler?

[Darksonn]

Without seeing the compiler error, I can't help you.

[fakecore]

It seems like the issue is that you are storing a Box<dyn FnMut(&mut Context, &Vec<u8>)> somewhere. You should add + Send to it so it looks like this:

Box<dyn FnMut(&mut Context, &Vec<u8>) + Send>

It works !!! thx, Darksonn.This problem bothered me few days, I should come here and ask early.
But why does it works? Could u pls tell me how it works or where I can some material about this?

[Darksonn]

A Box<dyn FnMut(&mut Context, &Vec<u8>)> without the + Send could contain a function that may not be sent across threads. Therefore, sending the box across threads is not allowed. However, this is a problem because things spawned with tokio::spawn may be moved from one thread to another at any .await.

The fact that the box does not actually contain a non-Send function is irrelevant. It's type allows it to do so, and the compiler does not look through every place you construct the box to figure out whether it ever contains a non-Send function.

[fakecore]

Ok, I see.
I saw the documents of tokio and rust multithread programming. Also, I noticed that +Send is necessary for multithread programming. I still didn't know how to solve it.Because i didn't know the +Send could use on Box<dyn FnMut(&mut Context, &Vec<u8>) + Send>.
Commonly, If you want to use a trait, you must use such grammar as impl trait for xx.
So, It's an implicit transfer or implicit implement?

[Darksonn]

Whenever you see dyn SomeTraitGoesHere, this refers to a special type called a "trait object". It's different from the trait SomeTraitGoesHere, which is a trait rather than a type. The trait object type can contain values of any type that implements the trait. To expand on this, trait objects can require multiple traits with a plus, which is what's happening when we add + Send. When you do this, the trait object can only contain values of types that implement both traits.

Important thing to note here is that without the + Send, the trait object could contain functions that don't implement Send, so the trait object type cannot be Send.

As for whether Send is implicitly implemented, yes. It is called an auto trait, which means that it is implemented for a type when all of its fields implement it.

[fakecore]

Thank you. I had read the feature 'auto trait'.It helps me a lot to understand.