这是不可能的，而且你写的东西很可能不是你想做的。
互斥锁守卫的目标是在互斥锁被丢弃时将其解锁。如果你把一个生命周期的守卫绑定到互斥体本身，你就是说它永远不会被丢弃，因此互斥体将永远被锁定。
不管怎样，你为什么需要警卫的资料？通常你不会在意，你只是希望它保持锁，只要它被引用。
也许你想这么做？你需要更多的上下文来看看这是否正是你想做的：D

use std::sync::{Arc, Mutex, MutexGuard};
struct Test {
    mutex: Arc<Mutex<()>>,
}
impl Test {
    pub fn new() -> Self {
        let mutex = Arc::new(Mutex::new(()));
        Self { mutex }
    }
    pub fn try_download(&self) -> Option<MutexGuard<()>> {
        let guard = self.mutex.try_lock();
        if guard.is_ok() {
            println!("Download started!");
            return guard.ok();
        } else {
            println!("Cannot download since it's already downloading");
            return None;
        }
    }
}
fn main() {
    let test = Test::new();
    // This could be kept alive like you said in an hashmap, so the guard is not dropped
    //  v
    let a = test.try_download(); // Download started!
    let b = test.try_download(); // Cannot download since it's already downloading
}

为什么你的代码不工作

实际上有两个问题
1.对未知堆栈空间的引用（segfault！）

impl<'a> Test<'a> {
    pub fn new() -> Self {
        let mutex = Arc::new(Mutex::new(()));
        //    ^
        //  This reference has the lifetime of mutex
        //          v
        let guard = &mutex.lock().unwrap(); 
        Self {
            mutex, // mutex is moved here, so guard points to something which is at this time
                   // unknown. This can be known only after the new stack frame is built
            guard,
        }
    }
}

1.互斥锁到底存储在哪里？在你的例子中，它位于函数new的堆栈框架上。然后将指向它的指针存储在结构中并返回它。通过返回，你也删除了堆栈，那么指针指向哪里呢？（segfault！）

impl<'a> Test<'a> {
    pub fn new() -> Self {
        let mutex = Arc::new(Mutex::new(()));
        //  MutexGuard is created here and put in the stack dropped when the function exits.
        //           v
        let guard = &mutex.lock().unwrap();
        Self { mutex, guard }
    }
}