atomx 0.2.10

Thread safe data structures based on atomic data types.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

use atomx::signal;

#[derive(Default)]
struct Dummy { id: usize }

impl Clone for Dummy {
    fn clone(&self) -> Self {
        // panic if clone would be called at any time in the code
        panic!("clone");
    }
}

fn main() {
    let (mut source, sink) = signal::sync::create::<Dummy>();
    source.modify(&mut |dummy| {dummy.id = 1});

    // run the consumer
    let t1 = std::thread::spawn(move || {
        let mut stop = false;
        while ! stop {
            // this is a zero copy read, we directly accessing the underlying memory here
            sink.process(&mut |dummy|{
                if dummy.id > 1000 {
                    stop = true
                }
            });
        }
    });

    // run the producer
    let t2 = std::thread::spawn(move || {
        loop {
            // this is a zero copy write, we directly modifying the underlying memory here
            let state = source.modify(&mut |dummy| {
                if dummy.id % 100 == 0 { println!("\nsrc dummy.id: {}", dummy.id) }
                else { print!(".") }
                // - counter intuitive, dummy id needs to be increased by 2
                // - because the signal has two memory slots and write will modify in place
                // - in combination with incrementing the id in one slot beforehand this
                //   will give an id incrementing by 1 each cycle
                dummy.id += 2;
            });
            use signal::sync::State::*;
            match state {
                AllGone => break,
                Receiving => (),
                Ready => ()
            }
        }
    });

    t1.join().expect("Couldn't join on the associated thread 1");
    t2.join().expect("Couldn't join on the associated thread 2");

}