thread-share 0.1.6

A Rust library for safe and efficient data sharing between threads with zero-copy operations, change detection, and enhanced thread management.
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use std::thread;
use std::time::Duration;
use thread_share::{share, simple_share};

#[test]
fn test_basic_operations() {
    let share = share!(42);
    assert_eq!(share.get(), 42);

    share.set(100);
    assert_eq!(share.get(), 100);

    share.update(|x| *x += 50);
    assert_eq!(share.get(), 150);
}

#[test]
fn test_thread_safety() {
    let share = share!(0);
    let share_clone = share.clone();

    let handle = thread::spawn(move || {
        for i in 1..=100 {
            share_clone.set(i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    let mut last_value = 0;
    for _ in 0..100 {
        let current = share.get();
        if current > last_value {
            last_value = current;
        }
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().unwrap();
    // Wait a bit to ensure the last value is set
    thread::sleep(Duration::from_millis(10));
    let final_value = share.get();
    assert_eq!(final_value, 100);
}

#[test]
fn test_simple_share() {
    let share = simple_share!("hello");
    assert_eq!(share.get(), "hello");

    share.set("world");
    assert_eq!(share.get(), "world");

    share.update(|s| *s = "rust");
    assert_eq!(share.get(), "rust");
}

#[test]
fn test_read_write_operations() {
    let share = share!(vec![1, 2, 3]);

    // Test read operation
    let sum = share.read(|v| v.iter().sum::<i32>());
    assert_eq!(sum, 6);

    // Test write operation
    let doubled = share.write(|v| {
        v.iter_mut().for_each(|x| *x *= 2);
        v.clone()
    });
    assert_eq!(doubled, vec![2, 4, 6]);
    assert_eq!(share.get(), vec![2, 4, 6]);
}

#[test]
fn test_wait_for_change() {
    let data = share!(false);
    let data_clone = data.clone();

    let handle = thread::spawn(move || {
        thread::sleep(Duration::from_millis(100));
        data_clone.set(true);
    });

    // Wait for change with timeout
    let timeout_occurred = data.wait_for_change(Duration::from_millis(50));
    assert!(timeout_occurred); // Should timeout

    // Wait for real change
    let timeout_occurred = data.wait_for_change(Duration::from_millis(200));
    assert!(!timeout_occurred); // Should not timeout

    handle.join().unwrap();
}

#[test]
fn test_multiple_clones() {
    let original = share!(0);
    let clone1 = original.clone();
    let clone2 = original.clone();

    // Change through one clone
    clone1.set(42);

    // Check that all clones see changes
    assert_eq!(original.get(), 42);
    assert_eq!(clone1.get(), 42);
    assert_eq!(clone2.get(), 42);

    // Change through another clone
    clone2.update(|x| *x += 8);

    // Check that all clones see changes
    assert_eq!(original.get(), 50);
    assert_eq!(clone1.get(), 50);
    assert_eq!(clone2.get(), 50);
}

#[test]
fn test_custom_struct() {
    #[derive(Clone, Debug, PartialEq)]
    struct TestStruct {
        value: i32,
        text: String,
    }

    let test_data = share!(TestStruct {
        value: 10,
        text: "test".to_string(),
    });

    let test_data_clone = test_data.clone();

    // Change in thread
    let handle = thread::spawn(move || {
        test_data_clone.update(|data| {
            data.value = 20;
            data.text = "updated".to_string();
        });
    });

    // Check original state
    let original = test_data.get();
    assert_eq!(original.value, 10);
    assert_eq!(original.text, "test");

    handle.join().unwrap();

    // Check updated state
    let updated = test_data.get();
    assert_eq!(updated.value, 20);
    assert_eq!(updated.text, "updated");
}