What is the difference between two tokio::spawn usages?

Question

I’m currently learning Tokio from its official tutorial, and the following code is part of the tutorial: https://tokio.rs/tokio/tutorial/spawning

use mini_redis::{Connection, Frame};
use tokio::net::{TcpListener, TcpStream};

#[tokio::main]
async fn main() {
   let listener = TcpListener::bind("127.0.0.1:6379").await.unwrap();

   loop {
       let (socket, _) = listener.accept().await.unwrap();
       
       // Option 1
       // tokio::spawn(process(socket));

       // Option 2
       tokio::spawn(async move {
           process(socket).await;
       });
   }
}

async fn process(socket: TcpStream) {
   let mut connection = Connection::new(socket);

   if let Some(frame) = connection.read_frame().await.unwrap() {
       println!("GOT: {:?}", frame);
       let response = Frame::Error("unimplemented".to_string());
       connection.write_frame(&response).await.unwrap();
   }
}

I have the following question regarding tokio::spawn usage:

What is the difference between these two usages of tokio::spawn?

• The first (commented out) directly passes process(socket) to tokio::spawn.
• The second wraps process(socket).await inside an async move block before passing it to tokio::spawn. This is the example in the tutorial.

Both seem to compile and run fine, so I’m wondering if there’s any real difference in behavior or performance implications.

Would appreciate any insights or explanations. Thanks!