Rust lock impl using atomic swap

lock.rs

use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
use std::thread;

struct Lock {
    lock: AtomicBool,
}

impl Lock {
    fn lock(&self) {
        while self.lock.swap(true, Ordering::Acquire) {}
    }
    fn unlock(&self) {
        self.lock.store(false, Ordering::Release);
    }
}

fn main() {
    let mut handles = vec![];
    static mut SH_MEM: i32 = 1;
    static L: Lock = Lock {
        lock: AtomicBool::new(false),
    };

    for _ in 0..10 {
        let handle = thread::spawn(|| unsafe {
            L.lock();
            println!("Modify {}", SH_MEM);
            SH_MEM += 1;
            L.unlock();
        });

        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }
    unsafe {
        println!("Result: {}", SH_MEM);
    }