尝试在 Arc 中使用互斥锁<mutex<t> &gt; 使用 Condvar </mutex<t>

Question

further along in trying to port my c++ timer queue to rust. Reading a lot of other peoples code, the rust library etc I came up with this scheme

I have an outer struct that clients use. It is simply a wrapper around an inner implementation. So I have

type QIFunc = Box<dyn Fn() -> () + Send>;

pub struct TimerQueueItem {
    when: Instant,
    name: String,
    what: QIFunc,
}

struct _TimerQueue {
    running: bool,
    stop: bool,
    condvar: Condvar,
    queue: Vec<TimerQueueItem>,
}

struct TimerQueue {
    inner: Arc<Mutex<_TimerQueue>>,
}

There is a dedicated thread that picks things off this queue and runs them. Works fine without the timing, what I need to do is a classic condvar thing

lock cv -> is queue empty -> wait. else pick item off queue (queue is sorted by due time)
look at item -> is it due yet, yes run it, no lock cv till it is due
while sleeping a new thing gets posted, so notify the cv to wake up thread and look at head of queue again.

I want to use the mutex thats in my Arc<Mutex<_TimerQueue>> since thats the logical queue lock. But I cannot work out how to get at it in such a way that it will compile.

I have this

impl TimerQueue {
    fn thr(&self) -> () {
        let inner = self.inner.clone();
        thread::spawn(move || {

            loop {
                //let tqi:TimerQueueItem;
                loop {
                  
                    let tqimp = &match inner.lock() {
                        Ok(tqimp) => tqimp,
                        _ => continue,
                    };

                    while !tqimp.stop && tqimp.queue.is_empty() {
                        tqimp.condvar.wait(xxx);
                    }

                    if tqimp.stop {
                        return;
                    }

                    let now = Instant::now();
                    let tqi = &tqimp.queue[0];

                    let due = tqi.when;
                    if due > now {
                        let wait = due - now;
                        tqimp.condvar.wait_timeout(xxx, wait);

                        let tqi = &tqimp.queue[0];
                        let now = Instant::now();
                        let due = tqi.when;
                        if due <= now {
                            (tqi.what)();
                        }
                    } else {
                        let tqi = &tqimp.queue[0];
                        (tqi.what)();
                    
                    }
                }
              //  (tqi.what)();
            }
        });
    }

but cannot work out what I need to put in the cv wait calls (where there is xxx at the moment). I have tried &, * clone,,,,. I am stuck. (The commented out code is me trying to pull out the execution of the 'what' to be outside the lock, stuck on that too but I am sure I can work that one out)

EDIT:

heres the entire source

use std::sync::{Arc, Condvar, Mutex};
use std::thread;
use std::time::Instant;

type QIFunc = Box<dyn Fn() -> () + Send>;

struct TimerQueueItem {
    when: Instant,
    name: String,
    what: QIFunc,
}

struct _TimerQueue {
    running: bool,
    stop: bool,
    condvar: Arc<Condvar>,
    queue: Vec<TimerQueueItem>,
}

pub struct TimerQueue {
    inner: Arc<Mutex<_TimerQueue>>,
}




impl TimerQueue {
    fn thr(&self) -> () {
        let inner = self.inner.clone();
        thread::spawn(move || {

            loop {
                //let tqi:TimerQueueItem;
                loop {
                  
                    let mut tqimp = &match inner.lock() {
                        Ok(tqimp) => tqimp,
                        _ => continue,
                    };
                    let cv = tqimp.condvar.clone();
                    while !tqimp.stop && tqimp.queue.is_empty() {
                        cv.wait(xxx);
                    }

                    if tqimp.stop {
                        return;
                    }

                    let now = Instant::now();
                    let tqi = &tqimp.queue[0];

                    let due = tqi.when;
                    if due > now {
                        let wait = due - now;
                        cv.wait_timeout(xxx, wait);

                        let tqi = &tqimp.queue[0];
                        let now = Instant::now();
                        let due = tqi.when;
                        if due <= now {
                            (tqi.what)();
                        }
                    } else {
                        let tqi = &tqimp.queue[0];
                        (tqi.what)();
                    
                    }
                }
              //  (tqi.what)();
            }
        });
    }

    fn set(&self, f: QIFunc, n: String, when: Instant) {
        let qi = TimerQueueItem {
            what: f,
            name: n,
            when: when,
        };

        let mut inner = self.inner.lock().unwrap();
        inner.queue.push(qi);
        inner.queue.sort_by_key(|k| k.when);
    }
    fn new() -> TimerQueue {
        let inner = Arc::new(Mutex::new(_TimerQueue {
            queue: Vec::new(),
            running: false,
            stop: false,
            condvar: Arc::new(Condvar::new()),
        }));
        TimerQueue { inner: inner }
    }
}

fn main() {
    let x = || {
        println!("hello");
    };
    let y = || {
        println!("hello2");
    };

    let tq = TimerQueue::new();

    tq.set(Box::new(x), String::from("yo"), Instant::now());
    tq.set(Box::new(y), String::from("yo"), Instant::now());

    thread::sleep_ms(10000);
}

Answer 1

Normally you should put the MutexGuard that was returned by lock , which in your case is tqimp . But you can't because that would require a mutable borrow (in the parameter) at the same time as another borrow (to access tqimp.condvar ). You will need to either store the CondVar outside the queue or to use an Arc :

struct _TimerQueue {
    running: bool,
    stop: bool,
    condvar: Arc<Condvar>,
    queue: Vec<TimerQueueItem>,
}

Then when you want to use it:

let mut tqimp = match inner.lock() { // tqimp can't be a reference
        Ok(tqimp) => tqimp,
        _ => continue,
    };
let condvar = tqimp.condvar.clone();
tqimp = condvar.wait (tqimp).unwrap();

Note that condvar.wait consumes tqimp and returns a new MutexGuard (because it releases the mutex until the condition triggers, then locks it again before returning).