Can't get RwLock to work in multithreaded app - rust

Question

I am trying to implement tokio::sync::RwLock because my app should re-load a configuration file if/when it changes. This involves re-assigning a Vec variable with a new one, but there could be many readers at any one time.
There is a struct called Manifest that represents a "list" of binaries available for a piece of hardware that I designed. The list is a JSON file which is parsed at startup and whenever it changes.
use notify::{watcher, RecursiveMode, Watcher};
use semver::Version;
use serde::{Deserialize, Serialize};
use std::sync::mpsc::channel;
use std::time::Duration;
use std::{fs::File, sync::Arc, thread};
use tokio::sync::RwLock;
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Binary {
version: Version,
hardware: Version,
requires: Version,
file: String,
}
pub struct Manifest {
path: String,
manifest_changed: bool,
binaries: Arc<RwLock<Vec<Binary>>>,
}
impl Manifest {
pub fn new(path: String) -> Manifest {
let bins = Arc::new(RwLock::new(Vec::new()));
thread::spawn(move || async move {
let bins = Arc::clone(&bins);
let (tx, rx) = channel();
let mut watcher = watcher(tx, Duration::from_secs(10)).unwrap();
watcher.watch(path, RecursiveMode::NonRecursive).unwrap();
loop {
match rx.recv() {
Ok(event) => {
let file = File::open(path).unwrap();
let mut bins = bins.write().await;
*bins = serde_json::from_reader(file).unwrap();
}
Err(e) => println!("watch error: {:?}", e),
}
}
});
Manifest {
path: path,
manifest_changed: true,
binaries: bins,
}
}
pub async fn GetAvailableBinaries(self, hwv: Version, fwv: Version) -> Vec<Binary> {
self.binaries.read().await.to_vec();
}
}
My issue is that the compiler complains:
future cannot be sent between threads safely
future created by async block is not `Send`
help: the trait `std::marker::Sync` is not implemented for `std::sync::mpsc::Receiver<notify::DebouncedEvent>`rustc
manifest.rs(28, 9): future created by async block is not `Send`
manifest.rs(35, 23): has type `&std::sync::mpsc::Receiver<notify::DebouncedEvent>` which is not `Send`
manifest.rs(38, 40): await occurs here, with `rx` maybe used later
manifest.rs(44, 13): `rx` is later dropped here
mod.rs(617, 8): required by this bound in `std::thread::spawn`
I'm not sure I understand why it matters if the channel Receiver implements Send because it's being created in the closure/thread. Further that that reasoning, I really don't know what to look for.