Struct ReentrantLock 

pub struct ReentrantLock { /* private fields */ }

ReentrantLock implemented using Semaphore(1).

This Lock does not need to be mutable on calling, it is safe to share across multiple threads even with read only mode.

Example:

use std::sync::Arc;
use std::time::Duration;
use std::thread;
use classic_sync::lock::ReentrantLock;
let lock = ReentrantLock::new();
let arc_lock = Arc::new(lock);
for i in 0..3 {
    let lock_copy = Arc::clone(&arc_lock);
    let tid = i;
    thread::spawn(move || {
        lock_copy.lock();
        println!("Now we are in critical section!");
        std::thread::sleep(Duration::from_secs(3));
        // Other people can't acquire the lock even when I am sleeping.
        lock_copy.unlock(); // You have to manually unlock it to release the lock
    });
}

Implementations

impl ReentrantLock

Implementation of ReentrantLock

pub fn new() -> ReentrantLock

Create a new Lock object. Lock can be shared using Arc with readonly access

pub fn lock(&self)

Acquire the lock and wait indefinitely for it to happen Calling on already locked lock will block forever (dead lock) It is calling internal semaphore’s p() operation effectively.

pub fn unlock(&self)

Release the lock. Do not call unlock multiple times. It will give non-exclusive access any more! It is calling internal semaphore’s v() operation effectively.

pub fn try_lock(&self, timeout: Duration) -> bool

Try to acquire a lock. Return true if lock is acquired. Return false if acquire timed out.