SendRequest is not Send

[vcxk]

I am new in Rust,
I want to build a http proxy . pass request and response throw server and client.

pub fn do_request_send(&self,req:Request<Incoming>) {
       let (tx,rx) = std::sync::mpsc::channel();
       // tx.send("t");
       let pq = req.uri().path_and_query().unwrap().as_str().to_string();
       let url = Uri::builder()
           .scheme(self.schema.as_str())
           .authority(format!("{}:{}",self.host,self.port))
           .path_and_query(pq)
           .build().unwrap();
       let method = req.method().as_str();
       let mut sender = self.sender.clone();

       tokio::spawn(async move {
          
           let mut builder = Request::builder()
               .uri(url)
               .method(method);

           for (n,v) in req.headers()  {
               builder = builder.header(n, v);
           }

           let mut buf = req.collect().await.unwrap().aggregate();
           let bs = buf.copy_to_bytes(buf.remaining());
           let fbody = Full::new(bs);

           let r = builder.body(fbody).unwrap();
           let mut sender = sender.lock().unwrap();
           let response = sender.send_request(r).await;
           tx.send(response);
       });
       
   }

But the code report an Error
future cannot be sent between threads safely
within [async block@src/csip/http_client.rs:113:22: 131:10], the trait Send is not implemented for std::sync::MutexGuard<'_, hyper::client::conn::http1::SendRequest<http_body_util::Full<bytes::Bytes>>>rustcClick for full compiler diagnostic
http_client.rs(129, 51): future is not Send as this value is used across an await
spawn.rs(166, 21): required by a bound in tokio::spawn

And a Service struct fn call return a Send Future.

[vcxk]

async fn loop_serve(client:HttpClient) {
        let (s,mut r) = tokio::sync::mpsc::channel(1);
        let (s2,mut r2) = tokio::sync::mpsc::channel(1);
        let req = Request::builder()
            .body(Full::new(Bytes::from(""))).unwrap();
        s.send(ARequest{
            req, 
            sender:s2
        });
        loop {
            let Some(req) = r.recv().await else {
                break;
            };
            let mut http_s = client.sender.lock().unwrap();
            let response = http_s.send_request(req.req).await.unwrap();
            _ = req.sender.send(response);
        }
    }

oh maybe it's ok like this.