Shared via Rust Playground

playground.rs

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

#[derive(PartialEq,Debug)]
enum Command {
    Idle,
    Busy,
}


fn poll_thread(sync_pair: Arc<(Mutex<Command>, Condvar)> )
{
    let &(ref mutex, ref cvar) = &*sync_pair;

    loop {
        let mut flag = mutex.lock().unwrap();
        while *flag == Command::Idle {
            println!("                      Waiting for non-idle state");
            flag = cvar.wait(flag).unwrap();
        }

        match *flag {
            Command::Idle => {panic!("WHAT IMPOSSIBLE!");},
            Command::Busy => {
                thread::sleep(time::Duration::from_millis(4));
            },
        }
    }
}

pub fn main() {

    println!("---------------------------------");
    println!("main_thread           loop_thread");
    println!("---------------------------------");
    let pair = Arc::new((Mutex::new(Command::Idle), Condvar::new()));
    let pclone = pair.clone();
    let rx_thread = thread::spawn( || poll_thread(pclone) );

    
    let &(ref mutex, ref cvar) = &*pair;

    for i in 0..10 {
        thread::sleep(time::Duration::from_millis(10));
        println!("i = {}", i);
        if i == 2 {
            println!("Setting Busy");
            let mut flag = mutex.lock().unwrap();
            *flag = Command::Busy;
            println!("flag is = {:?}", *flag);
            cvar.notify_one();
        }
        else if i == 4 {
            println!("Setting Idle");
            let mut flag = mutex.lock().unwrap();
            println!("Got mutex");
            *flag = Command::Idle;
            println!("flag is = {:?}", *flag);
            cvar.notify_one();
        }
    }
    println!("completed loop.");

    rx_thread.join().unwrap();
}