Rust语言从入门到精通系列 - Atomic原子工具类

1
use std::sync::Arc;
2
use std::sync::atomic::{AtomicUsize, Ordering};
3

4
fn main() {
5
    let counter = Arc::new(AtomicUsize::new(0));
6

7
    for _ in 0..10 {
8
        let cc = counter.clone();
9
        std::thread::spawn(move|| {
10
            for _ in 0..100 {
11
                cc.fetch_add(1, Ordering::SeqCst);
12
            }
13
        });
14
    }
15

16
    std::thread::sleep(std::time::Duration::from_millis(1000));
17

18
    println!("Counter: {}", counter.load(Ordering::SeqCst));
19
}
20
//    输出结果：
21
//  Counter: 1000

1
use std::sync::Arc;
2
use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering};
3

4
#[derive(Debug)]
5
struct SpinLock {
6
    locked: AtomicBool,
7
}
8

9
impl SpinLock {
10
    fn new() -> SpinLock {
11
        SpinLock { locked: AtomicBool::new(false) }
12
    }
13

14
    fn lock(&self) {
15
        while self.locked.compare_and_swap(false, true, Ordering::SeqCst) != false {}
16
    }
17

18
    fn unlock(&self) {
19
        self.locked.store(false, Ordering::SeqCst);
20
    }
21
}
22

23
fn main() {
24
    let lock = Arc::new(SpinLock::new());
25

26
    {
27
        let cl = lock.clone();
28
        std::thread::spawn(move || {
29
            cl.lock();
30
            println!("Thread 1 acquired lock");
31
            std::thread::sleep(std::time::Duration::from_millis(1000));
32
            cl.unlock();
33
            println!("Thread 1 released lock");
34
        });
35
    }
36
    {
37
        let cl = lock.clone();
38
        std::thread::spawn(move || {
39
            cl.lock();
40
            println!("Thread 2 acquired lock");
41
            std::thread::sleep(std::time::Duration::from_millis(1000));
42
            cl.unlock();
43
            println!("Thread 2 released lock");
44
        });
45
    }
46

47
    std::thread::sleep(std::time::Duration::from_millis(3000));
48
}
49
//  输出结果：
50
// Thread 1 acquired lock
51
// Thread 2 acquired lock
52
// Thread 1 released lock
53
// Thread 2 released lock

1
use std::sync::atomic::{AtomicUsize, Ordering};
2
use std::sync::Arc;
3

4
struct Counter {
5
    count: AtomicUsize,
6
}
7

8
impl Counter {
9
    fn new() -> Counter {
10
        Counter { count: AtomicUsize::new(1) }
11
    }
12

13
    fn add_ref(&self) -> usize {
14
        self.count.fetch_add(1, Ordering::SeqCst)
15
    }
16

17
    fn release(&self) -> usize {
18
        let count = self.count.fetch_sub(1, Ordering::SeqCst);
19

20
        if count == 1 {
21
            std::mem::drop(self);
22
        }
23

24
        count - 1
25
    }
26
}
27

28
fn main() {
29
    let counter = Arc::new(Counter::new());
30

31
    let thread1 = {
32
        let counter = Arc::clone(&counter);
33
        std::thread::spawn(move || {
34
            let count = counter.add_ref();
35
            println!("Thread 1: count = {}", count);
36
        })
37
    };
38

39
    let thread2 = {
40
        let counter = Arc::clone(&counter);
41
        std::thread::spawn(move || {
42
            let count = counter.add_ref();
43
            println!("Thread 2: count = {}", count);
44
        })
45
    };
46

47
    let thread3 = {
48
        let counter = Arc::clone(&counter);
49
        std::thread::spawn(move || {
50
            let count = counter.release();
51
            println!("Thread 3: count = {}", count);
52
        })
53
    };
54

55
    let thread4 = {
56
        let counter = Arc::clone(&counter);
57
        std::thread::spawn(move || {
58
            let count = counter.release();
59
            println!("Thread 4: count = {}", count);
60
        })
61
    };
62

63
    thread1.join().unwrap();
64
    thread2.join().unwrap();
65
    thread3.join().unwrap();
66
    thread4.join().unwrap();
67
}
68
//    输出结果：
69
// Thread 1: count = 1
70
// Thread 3: count = 1
71
// Thread 2: count = 1
72
// Thread 4: count = 1