Shared State Concurrency

One common challenge in concurrency is managing shared state across multiple threads. Rust's ownership model, along with types like Mutex and Arc (atomic reference counting), makes this task safe and efficient.

In this challenge, you will implement a generic shared state system and use it to create thread-safe counters and other shared data structures.

Your Task

Implement three functions that demonstrate different aspects of shared state concurrency:

create_shared_data: Creates shared state with any type T
increment_counter: Demonstrates multiple threads modifying shared state
modify_shared_data: Generic function for thread-safe modifications

Requirements

The create_shared_data function should:
- Accept any type T
- Wrap it in a Mutex and Arc
- Return the thread-safe container
The increment_counter function should:
- Accept an Arc<Mutex<i32>>
- Spawn the specified number of threads
- Return handles to all spawned threads
The modify_shared_data function should:
- Perform modifications in a new thread
- Return the thread handle

Notes

Ignore error handling for this challenge, you can use unwrap() to simplify the code
Have a look at the main function to see how the functions are used

Hints

Click here to reveal hints

Use Arc::new(Mutex::new(initial)) to create thread-safe containers
Remember to cheap clone the Arc when passing it to a new thread. e.g. let cloned = Arc::clone(&shared_data)
Use lock().unwrap() to access the data inside the Mutex
To send data to a thread, the data must implement the Send trait and have a lifetime that outlives the thread 'static

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

AKA.MoneyTaker

M4Bo2

2 days ago

57.13ms

93.20kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    let mut handles = Vec::new();
    for _ in 0..threads {
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            for _ in 0..increments {
                let mut num = counter_clone.lock().unwrap();
                *num += 1;
            }
        });
        handles.push(handle);
    }
    handles
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    // 3. Use a new thread to modify the shared data
    let data_clone = Arc::clone(&data);
    thread::spawn(move || {
        let mut data = data_clone.lock().unwrap();
        modifier(&mut data);
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

ludovicknecht

3 days ago

57.61ms

93.20kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    let mut handles = vec![];
    for _ in 0..threads {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(
            move || {
                let mut num  = counter.lock().unwrap();
                *num += increments as i32;
            }
        );
        handles.push(handle);
    }
    handles
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    // 3. Use a new thread to modify the shared data
    thread::spawn(
        move || {
            let mut inner_data = data.lock().unwrap();
            modifier(&mut inner_data);
        }
    )
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

Ayushman Rathore

Spartan09

5 days ago

60.21ms

93.21kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    let mut handles = Vec::new();
    for _ in 0..threads {
        let counter = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            let mut data = counter.lock().unwrap();
            *data += increments as i32;
        }))
    }
    handles
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    thread::spawn(move || {
        let mut data = data.lock().unwrap();
        modifier(&mut data)
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

Jun Huang

leemars

9 days ago

59.72ms

92.37kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    (0..threads).into_iter()
        .map(|_| Arc::clone(&counter))
        .map(|counter| {
            thread::spawn(move || {
                let mut data = counter.lock().unwrap();
                *data += increments as i32;
            })
        }).collect()
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    // 3. Use a new thread to modify the shared data
    let data = Arc::clone(&data);
    thread::spawn(move || {
        let mut data = data.lock().unwrap();
        modifier(&mut *data);
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

Algorab

10 days ago

58.21ms

92.73kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    (0..threads).map(|_| {
        let counter = counter.clone();
        thread::spawn(move || {
            let mut counter_guard = counter.lock().unwrap();
            *counter_guard += increments as i32;
        })
    }).collect()
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    // 3. Use a new thread to modify the shared data
    thread::spawn(move || {
        let mut data = data.lock().unwrap();
        modifier(&mut *data);
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

Kyle Diaz

kylediaz

11 days ago

56.58ms

92.37kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    (0..threads)
        .map(|_| Arc::clone(&counter))
        .map(|counter| thread::spawn(move || {
                let mut counter = counter.lock().unwrap();
                *counter += increments as i32;          
            })
        )
        .collect()
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    thread::spawn(move || {
        let mut data = data.lock().unwrap();
        modifier(&mut data);
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

Jordan

Jordan-Haidee

11 days ago

60.91ms

93.20kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    let mut threads_buf = vec![];
    for _ in 0..threads {
        let c = counter.clone();
        let t = thread::spawn(move || {
            *c.lock().unwrap() += increments as i32;
        });
        threads_buf.push(t);
    }
    threads_buf
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    // 3. Use a new thread to modify the shared data
    let d = data.clone();
    thread::spawn(move || {
        modifier(&mut d.lock().unwrap());
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

rawar089

11 days ago

58.83ms

91.95kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    let mut ret:Vec<JoinHandle<()>> = Vec::with_capacity(threads);
    for _ in 0..threads {
        let cloned =Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut x = cloned.lock().unwrap();
            *x += increments as i32;
        });
        ret.push(handle);
    }
    ret
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    // 3. Use a new thread to modify the shared data
    let cloned = Arc::clone(&data);
    thread::spawn(move || {
        let mut data = cloned.lock().unwrap();
        modifier(&mut data);
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

Nikita Smirnov

Nismirno

12 days ago

59.12ms

93.20kb

use std::ops::DerefMut;
use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    let mut res: Vec<JoinHandle<()>> = vec![];
    for _ in 0..threads {
        let shared_counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut guard = shared_counter.lock().unwrap();
            *guard += increments as i32;
        });
        res.push(handle);
    }
    res
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    // 3. Use a new thread to modify the shared data
    thread::spawn(move || modifier(&mut data.lock().unwrap()))
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

alemack17

14 days ago

57.46ms

92.73kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    
    
    (0..threads)
        .map(|_| {
            let counter=counter.clone();
            thread::spawn(move || {
                let mut counter=counter.lock().unwrap();
                *counter += increments as i32;
            })}).collect()
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    // 3. Use a new thread to modify the shared data
    thread::spawn(move || modifier(& mut data.lock().unwrap()))
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

Christopher Nielson

c-nielson

16 days ago

56.98ms

93.20kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    let mut handles = vec![];
    
    for _ in 0..threads {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            *counter.lock().unwrap() += increments as i32
        });
        handles.push(handle);
    }
    
    handles
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    let data_copy = Arc::clone(&data);
    thread::spawn(move || {
        modifier(&mut *data_copy.lock().unwrap());
    })
}

Elliott Draper

ejdraper

19 days ago

62.13ms

93.21kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    let mut handles: Vec<JoinHandle<()>> = vec![];
    for _ in 0..threads {
        let counter = Arc::clone(&counter);
        handles.push(
            thread::spawn(move || {
                let mut counter = counter.lock().unwrap();
                *counter += increments as i32;
            })
        )
    }
    return handles;
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    thread::spawn(move || {
        let mut d = data.lock().unwrap();
        modifier(&mut d);
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

kosay

sarub0b0

19 days ago

57.15ms

92.73kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    (0..threads)
        .map(|_| {
            let counter = Arc::clone(&counter);
            thread::spawn(move || {
                let mut counter = counter.lock().unwrap();
                *counter += increments as i32;
            })
        })
        .collect()
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    thread::spawn(move || {
        let mut data = data.lock().unwrap();
        modifier(&mut data);
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

Oebelus

oebelus

20 days ago

56.52ms

93.20kb

use std::sync::{Arc, Mutex};
use std::thread::JoinHandle;
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    let mut spawned: Vec<JoinHandle<()>> = vec![];
    for _ in 0..threads {
        let counter = Arc::clone(&counter);
        spawned.push(std::thread::spawn(move || {
            let mut counter = counter.lock().unwrap();
            *counter += increments as i32;
        }));
    }
    spawned
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    std::thread::spawn(move || {
        let mut modify = data.lock().unwrap();
        modifier(&mut modify);
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

Jonathan Voss

jvoss

21 days ago

58.12ms

93.23kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    let mut spawned_threads: Vec<JoinHandle<()>> = Vec::new();
    
    for _ in 0..threads {
        // clone the Arc again here for each thread to resolve ownership issues
        let counter = Arc::clone(&counter);
        spawned_threads.push(
            thread::spawn(move || {
                // obtain the lock and unwrap
                let mut counter = counter.lock().unwrap();
                // increment the counter by the given increments
                *counter += increments as i32;
            })
        );
    }
    spawned_threads
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    // 3. Use a new thread to modify the shared data
    thread::spawn(move || {
        let mut data = data.lock().unwrap();
        modifier(&mut data)
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

TaiPoole

22 days ago

57.57ms

92.69kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    (0..threads).map(|_| {let counter = counter.clone(); thread::spawn(move || {
        *Arc::clone(&counter).lock().unwrap() += increments as i32
    })}).collect()
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    thread::spawn(move || {
        modifier(&mut data.lock().unwrap());
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

Jim Lawton

jimlawton

22 days ago

57.83ms

93.27kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    let mut v = Vec::<JoinHandle<()>>::new();
    for _ in 0..threads {
        let ctr = counter.clone();
        v.push(thread::spawn(move || {
            let mut c = ctr.lock().unwrap();
            *c += increments as i32;
        }));
    }
    v
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    thread::spawn(move || {
        let mut d = data.lock().unwrap();
        modifier(&mut (*d));
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

Justin Maillet

justy777

23 days ago

58.81ms

92.73kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    (0..threads).map(|_| {
        let counter = Arc::clone(&counter);
        thread::spawn(move || {
            let mut counter = counter.lock().unwrap();
            *counter += increments as i32;
        })
    })
    .collect()
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    // 3. Use a new thread to modify the shared data
    let data = Arc::clone(&data);
    thread::spawn(move || {
        let mut data = data.lock().unwrap();
        modifier(&mut data);
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

Stefan Roas

sroas

23 days ago

59.64ms

92.73kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    (0..threads)
        .map(|_| {
            let counter = Arc::clone(&counter);
            thread::spawn(move || {
                let mut c = counter.lock().unwrap();
                *c += increments as i32;
            })
        })
        .collect()
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    // 3. Use a new thread to modify the shared data
    let data = Arc::clone(&data);
    thread::spawn(move || {
        modifier(&mut data.lock().unwrap());
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

dawwestk

a month ago

59.36ms

93.23kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    let mut handles: Vec<JoinHandle<()>> = vec![];
    for _ in 0..threads {
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            *counter_clone.lock().unwrap() += increments as i32;
        });
        handles.push(handle);
    }
    handles
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    // 3. Use a new thread to modify the shared data
    let data_clone = Arc::clone(&data);
    thread::spawn(move || {
        modifier(&mut data_clone.lock().unwrap())
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}

PangoSea

kapaseker

a month ago

60.74ms

92.57kb

use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
use std::ops::DerefMut;
pub fn create_shared_data<T>(initial: T) -> Arc<Mutex<T>> {
    // 1. Initialize and return a new Arc<Mutex<T>> with the initial value
    Arc::new(Mutex::new(initial))
}
pub fn increment_counter(
    counter: Arc<Mutex<i32>>,
    threads: usize,
    increments: usize,
) -> Vec<JoinHandle<()>> {
    // 2. Increment the counter by the given increments using the given number of threads
    (0..threads).map(|thread_id| {
        thread::spawn({
            let mut counter = counter.clone();
            move || {
                let mut counter = counter.lock().unwrap();
                *counter = *counter + increments as i32;
            }
        })
    }).collect::<Vec<JoinHandle<()>>>()
}
pub fn modify_shared_data<T: Send + 'static>(
    data: Arc<Mutex<T>>,
    modifier: fn(&mut T),
) -> JoinHandle<()> {
    // 3. Use a new thread to modify the shared data
    thread::spawn({
        let mut a = data.clone();
        move || {
            modifier(a.lock().unwrap().deref_mut());
        }
    })
}
// Example usage
pub fn main() {
    let counter = create_shared_data(0);
    let handles = increment_counter(Arc::clone(&counter), 5, 10);
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter value: {}", *counter.lock().unwrap());
    let shared_string = create_shared_data(String::from("Hello"));
    let handle = modify_shared_data(shared_string.clone(), |s| s.push_str(" World"));
    handle.join().unwrap();
    println!("Modified string: {}", *shared_string.lock().unwrap());
}