Зачем нужна условная переменная?

Зачем нужна условная переменная в данном случае? Почему бы не использовать просто мьютекс? Что значит drop(self.lock.lock().unwrap())?

    fn park(&self, timeout: Option<Duration>) -> bool {
        if self
            .state
            .compare_exchange(NOTIFIED, EMPTY, SeqCst, SeqCst)
            .is_ok()
        {
            return true;
        }

        if let Some(dur) = timeout {
            if dur == Duration::from_millis(0) {
                return false;
            }
        }

        let mut m = self.lock.lock().unwrap();

        match self.state.compare_exchange(EMPTY, PARKED, SeqCst, SeqCst) {
            Ok(_) => {}
            Err(NOTIFIED) => {
                let old = self.state.swap(EMPTY, SeqCst);
                assert_eq!(old, NOTIFIED);
                return true;
            }
            Err(n) => panic!("inconsistent park_timeout state: {}", n),
        }

        match timeout {
            None => {
                loop {
                    m = self.condvar.wait(m).unwrap();

                    if self.state.compare_exchange(NOTIFIED, EMPTY, SeqCst, SeqCst).is_ok() {
                        return true;
                    }
                }
            }
            Some(timeout) => {
                let (_m, _result) = self.condvar.wait_timeout(m, timeout).unwrap();

                match self.state.swap(EMPTY, SeqCst) {
                    NOTIFIED => true, 
                    PARKED => false,
                    n => panic!("inconsistent park_timeout state: {}", n),
                }
            }
        }
    }

    pub fn unpark(&self) -> bool {
        match self.state.swap(NOTIFIED, SeqCst) {
            EMPTY => return true,    
            NOTIFIED => return false,
            PARKED => {}              
            _ => panic!("inconsistent state in unpark"),
        }

        drop(self.lock.lock().unwrap());
        self.condvar.notify_one();
        true
    }
}```