如何“解锁”RwLock？

Question

我正在尝试解决螺纹环问题。在每个线程中，我读取了令牌值

• 如果它不是我的，请检查它是否是程序的结尾

  • 如果是然后完成线程
  • 否则，再次阅读并重复

• 如果它是我的（即有我的 id）然后获取写锁，增加令牌的值，检查它是否结束然后告诉主线程我完成它并完成当前线程循环

• 如果还没有结束，则释放写锁，重新开始读

没有解锁。这里有我需要的解锁吗？

看来我也应该释放读锁，因为如果有人读数据，写锁就不会发生。有必要吗？

fn main() {
    use std::sync::{Arc, RwLock};
    use std::thread;
    use std::sync::mpsc::channel;

    const N: usize = 5; //503;
    const STOP_POINT: usize = 100;

    let n = Arc::new(RwLock::new(1));

    let (sender, reciever) = channel();

    for i in 1..N {
        let (n_c, channel) = (n.clone(), sender.clone());
        // println!("Thread n.{} beeing created!", i);

        let a = thread::Builder::new()
            .name(i.to_string())
            .spawn(move || -> () {
                loop {
                    let mut read_only = n_c.read().unwrap();
                    let say_my_name = (*thread::current().name().unwrap()).to_string();

                    // println!("Thread {} says: gonna try!", say_my_name);
                    while (*read_only % N) != i {
                        if *read_only == 0 {
                            break;
                        }
                        // println!("Thread {} says: aint mine!", say_my_name);
                        read_only = n_c.read().unwrap();
                    } // WAIT

                    println!("Thread {} says: my turn!", say_my_name);
                    let mut ref_to_num = n_c.write().unwrap();
                    *ref_to_num += 1;

                    if *ref_to_num == STOP_POINT {
                        channel.send(say_my_name).unwrap();
                        break;
                    }
                }
                ()
            });
        assert_eq!(a.is_ok(), true);
        // thread::spawn();
        // println!("Thread n.{} created!", i);
    }

    println!("{}", reciever.recv().unwrap());
}

Answer 1

要释放锁，您可以让它超出范围或通过调用显式调用其析构函数drop。

以下是drop在两个地方编写程序的方法：

fn main() {
    use std::sync::{Arc, RwLock};
    use std::sync::mpsc::channel;
    use std::thread;
    use std::time::Duration;

    const N: usize = 503;
    const STOP_POINT: usize = 100;

    let n = Arc::new(RwLock::new(1));

    let (sender, receiver) = channel();

    for i in 1..N {
        let (n_c, channel) = (n.clone(), sender.clone());
        // println!("Thread n.{} beeing created!", i);

        thread::Builder::new()
            .name(i.to_string())
            .spawn(move || {
                loop {
                    let mut read_only = n_c.read().unwrap();
                    let say_my_name = (*thread::current().name().unwrap()).to_string();

                    // println!("Thread {} says: gonna try!", say_my_name);
                    while (*read_only % N) != i {
                        if *read_only == 0 {
                            break;
                        }

                        drop(read_only); // release the lock before sleeping
                        // println!("Thread {} says: aint mine!", say_my_name);
                        thread::sleep(Duration::from_millis(1));
                        read_only = n_c.read().unwrap();
                    }

                    println!("Thread {} says: my turn!", say_my_name);
                    drop(read_only); // release the read lock before taking a write lock
                    let mut ref_to_num = n_c.write().unwrap();
                    *ref_to_num += 1;

                    if *ref_to_num == STOP_POINT {
                        channel.send(say_my_name).unwrap();
                        break;
                    }
                }
            })
            .expect("failed to spawn a thread");
        // println!("Thread n.{} created!", i);
    }

    println!("{}", receiver.recv().unwrap());
}

需要注意的是，如果我们不重新分配read_lock的while循环，编译器会给出一个错误，因为read_lock我们所说的后未持有有效的值drop(read_lock)。Rust 适用于暂时未初始化的局部变量，但当然我们需要重新初始化它们才能再次使用它们。

以下是如何编写线程的主循环以使用范围来替换drops 之一：

loop {
    let say_my_name = (*thread::current().name().unwrap()).to_string();
    {
        let mut read_only = n_c.read().unwrap();

        // println!("Thread {} says: gonna try!", say_my_name);
        while (*read_only % N) != i {
            if *read_only == 0 {
                break;
            }

            drop(read_only);
            thread::sleep(Duration::from_millis(1));
            // println!("Thread {} says: aint mine!", say_my_name);
            read_only = n_c.read().unwrap();
        }

        println!("Thread {} says: my turn!", say_my_name);
    } // read_only is dropped here

    let mut ref_to_num = n_c.write().unwrap();
    *ref_to_num += 1;

    if *ref_to_num == STOP_POINT {
        channel.send(say_my_name).unwrap();
        break;
    }
}