critical_section.rs

pub fn with_critical_section<F, R>(object: &Bound<'_, PyAny>, f: F) -> R
where
    F: FnOnce() -> R,
{
    #[cfg(Py_GIL_DISABLED)]
    {
        struct Guard(crate::ffi::PyCriticalSection);

        impl Drop for Guard {
            fn drop(&mut self) {
                unsafe {
                    crate::ffi::PyCriticalSection_End(&mut self.0);
                }
            }
        }

        let _guard = unsafe {
            let mut section = std::mem::zeroed();
            crate::ffi::PyCriticalSection_Begin(&mut section, object.as_ptr());
            Guard(section)
        };
        f()
    }
    #[cfg(not(Py_GIL_DISABLED))]
    {
        f()
    }
}

test.rs

    #[test]
    fn test_critical_section() {
        let dict = Python::with_gil(|py| -> Py<PyDict> { PyDict::new(py).unbind() });
        let barrier = Barrier::new(2);

        std::thread::scope(|s| {
            s.spawn(|| {
                Python::with_gil(|py| {
                    let d = dict.bind(py);
                    with_critical_section(d, || {
                        barrier.wait();
                        std::thread::sleep(std::time::Duration::from_millis(10));
                        d.set_item(42, 42).unwrap();
                    })
                });
            });
            s.spawn(|| {
                barrier.wait();
                Python::with_gil(|py| {
                    let d = dict.bind(py);

                    assert_eq!(
                        d.get_item(42).unwrap().unwrap().extract::<usize>().unwrap(),
                        42
                    );
                });
            });
	});
  }