More methods to OnceCell

[tisonkun]

• get_or_try_init
• get_mut
• get_mut_or_init
• get_mut_or_try_init
• set
• try_insert
• take

You can refer to:

• https://github.com/tokio-rs/tokio/blob/master/tokio/src/sync/once_cell.rs
• https://doc.rust-lang.org/std/sync/struct.OnceLock.html
• impl get_mut_or_init and get_mut_or_try_init for OnceCell and OnceLock rust-lang/rust#114788

Also, it's possible to add a LazyCell primitive that has a pre-configured initializer (closure).

[BewareMyPower]

I'm wondering if it's worth implementing a get_mut_or_init. This method should accept a mutable reference so that it cannot be called concurrently.

A typical use case for modifying a mutable reference is calling get_or_init on an OnceCell whose value is something like Arc<Mutex<T>> so that it can be modified concurrently.

#[test]
fn multi_init_mut() {
    let rt = tokio::runtime::Builder::new_multi_thread()
        .worker_threads(4)
        .enable_time()
        .build()
        .unwrap();

    static CELL: OnceCell<AtomicUsize> = OnceCell::new();

    rt.block_on(async {
        const N: usize = 100;

        let mut handles = vec![];
        for i in 0..N {
            handles.push(rt.spawn(async move {
                let result = CELL
                    .get_or_init(move || async move { AtomicUsize::new(1000 + i) })
                    .await;
                result.fetch_add(1, Ordering::Relaxed);
                tokio::time::sleep(Duration::from_millis(100)).await;
                result.load(Ordering::Relaxed)
            }));
        }
        let mut values = vec![];
        for handle in handles {
            values.push(handle.await.unwrap());
        }
        let value = CELL.get().unwrap().load(Ordering::Relaxed);
        assert!(
            value >= 1000 + N && value < 1000 + N + N,
            "final value: {}",
            value
        );
        for v in values {
            assert_eq!(v, value);
        }
    });
}

[tisonkun]

You can see the linked issue.

While async primitives can be used to share cross threads, our OnceCell can be used as an analogy to std OnceLock while its pass-in function is an async fn.

Thus, this can be used as a cell that initialized only once and need not shared among threads.

[tisonkun]

See rust-lang/rust#74465 (comment)

[BewareMyPower]

Okay, it makes sense