解决这个问题的一种方法是Box-ing VecDeque，这样就可以将一个克隆的引用传递给process_queue函数。
使用Box允许您在堆上分配VecDeque，以便您可以为派生的线程提供对Vec的引用，并且仍然可以在当前线程中改变队列。
这看起来像：

let mut queue = Box::new(VecDeque::new());
let queue_clone = queue.clone();

thread::spawn(|| {
    // queue_clone is now moved into the fn closure and is 
    // not accessible to the code below
    process_queue(queue_clone)
});

并且可以更新process_queue以接受正确的类型：

fn process_queue(queue: Box<VecDeque<String>>) -> () { }

请注意，使用这种实现，process_queue只在线程产生时运行一次，如果您希望process_queue在每次队列更改时执行某些操作，则遵循其他人的建议，使用类似Channels这样的语句是最有意义的。

感谢您的所有回复
从所有的响应中，我了解到使用通道并将接收器循环移动到其他线程（如user4815162342所建议的）将是最好的解决方案

根据您的建议，我使用渠道成功地实现了我所要做的事情。
最终工作代码粘贴在下面

use std::thread;
use std::time::Duration;
use notify::{RecommendedWatcher, RecursiveMode, Watcher, Config};
use std::path::Path;
use std::path::PathBuf;

//
fn main() {

    //let path = std::env::args()
     //   .nth(1)
     //   .expect("Argument 1 needs to be a path");
    //println!("watching {}", path);
    let path="c:\\testfolder";    

    if let Err(e) = watch(path) {
        println!("error: {:?}", e)
    }

}

fn watch<P: AsRef<Path>>(path: P) -> notify::Result<()> {
    let (tx, rx) = std::sync::mpsc::channel();      

    // Automatically select the best implementation for your platform.
    // You can also access each implementation directly e.g. INotifyWatcher.
    let mut watcher = RecommendedWatcher::new(tx, Config::default())?;

    // Add a path to be watched. All files and directories at that path and
    // below will be monitored for changes.

    let handle=thread::spawn(move || {

        // everything in here runs        

        for res in rx {
            match res {
                Ok(event) =>{

                   // println!("changed: {:?}", event.paths); 
                    let os_str:String = String::from(event.paths[0].to_str().unwrap());
                    println!("file name: {}", os_str);               

                },
                Err(e) => println!("watch error: {:?}", e),
            }
        }

    }); 

    watcher.watch(path.as_ref(), RecursiveMode::Recursive)?;    
    handle.join();  

    Ok(())
}

在您的情况下，使用Rust的MPSC（多生产者单消费者，即本质上是一个队列）可能是最好的。您也可以使用Arc和Mutex结构体创建一个在多个线程之间共享的变量，但这会过度使用，并可能会影响性能（任何时候只有一个线程可以访问该变量）。
下面是一个多线程MPSC的示例，我将让您根据您的基础架构对其进行调整：

use std::{sync::mpsc, thread};

fn main() {
    let (sender, receiver) = mpsc::channel();

    let handle_1 = thread::spawn(|| {
        thread_1(sender);
    });
    let handle_2 = thread::spawn(|| {
        thread_2(receiver);
    });

    handle_1.join().unwrap();
    handle_2.join().unwrap();
}

// the enum must have the Send trait (automatically implemented)
enum Instruction {
    Print(String),
    Exit
}

fn thread_1(sender: mpsc::Sender<Instruction>) {
    sender.send(Instruction::Print("I".to_owned())).unwrap();
    sender.send(Instruction::Print("like".to_owned())).unwrap();
    sender.send(Instruction::Print("Rust".to_owned())).unwrap();
    sender.send(Instruction::Print(".".to_owned())).unwrap();
    sender.send(Instruction::Exit).unwrap();
}

fn thread_2(receiver: mpsc::Receiver<Instruction>) {
    'global_loop: loop {
        for received in receiver.recv() {
            match received {
                Instruction::Print(string) => print!("{} ", string),
                Instruction::Exit => {
                    println!("");
                    break 'global_loop;
                }
            }
        }
    }
}