**Mastering Rust: From Basics to Systems Programming** ==================================================== **Section Title:** Concurrency in Rust ===================================== **Topic:** Build a concurrent Rust application using threads or async programming. ================================================================= In this lab, we will explore how to build a concurrent Rust application using threads or async programming. You will learn how to create and manage threads, share data between threads, and use async/await to write concurrent code. **Lab Objective:** ---------------- By the end of this lab, you will be able to: * Create and manage threads in Rust using the `std::thread` module * Share data between threads using `std::sync` primitives * Use async/await to write concurrent code in Rust * Apply concurrency concepts to build a concurrent Rust application **Prerequisites:** ----------------- * Understanding of Rust basics (variables, data types, functions, etc.) * Familiarity with Rust's ownership and borrowing system * Knowledge of Rust's concurrency concepts (threads, async/await, etc.) **Lab Content:** --------------- ### Creating and Managing Threads In Rust, you can create a thread using the `std::thread::spawn` function. This function takes a closure as an argument, which is executed in a new thread. ```rust use std::thread; fn main() { let handle = thread::spawn(|| { println!("Hello from the child thread!"); }); // Wait for the child thread to finish handle.join().unwrap(); println!("Hello from the main thread!"); } ``` In this example, we create a new thread using `std::thread::spawn` and pass a closure that prints a message to the console. We then wait for the child thread to finish using `handle.join().unwrap()`. ### Sharing Data between Threads To share data between threads, you can use `std::sync` primitives such as `Mutex` or `RwLock`. These primitives allow you to safely share data between threads. ```rust use std::sync::{Arc, Mutex}; use std::thread; fn main() { let counter = Arc::new(Mutex::new(0)); let mut handles = vec![]; for _ in 0..10 { let counter_clone = Arc::clone(&counter); let handle = thread::spawn(move || { *counter_clone.lock().unwrap() += 1; }); handles.push(handle); } for handle in handles { handle.join().unwrap(); } println!("Final counter value: {}", *counter.lock().unwrap()); } ``` In this example, we use an `Arc` to share a `Mutex` between threads. We create multiple threads that increment the counter value using `Mutex::lock`. We then wait for all threads to finish and print the final counter value. ### Using Async/Await To write concurrent code using async/await, you can use the `tokio` crate. ```rust use tokio; async fn hello_world() { println!("Hello from async/await!"); } #[tokio::main] async fn main() { let mut handles = vec![]; for _ in 0..10 { let handle = tokio::spawn(hello_world()); handles.push(handle); } for handle in handles { handle.await.unwrap(); } } ``` In this example, we define an async function `hello_world` using the `async` keyword. We then create multiple async tasks using `tokio::spawn` and wait for them to finish using `handle.await.unwrap()`. **Practical Exercise:** --------------------- Build a concurrent Rust application using threads or async programming that simulates a simple bank account system. The system should allow multiple threads to deposit and withdraw money concurrently. * Create a `BankAccount` struct that has a `balance` field and methods for depositing and withdrawing money. * Use `std::sync` primitives to safely share the `BankAccount` struct between threads. * Create multiple threads that concurrently deposit and withdraw money from the `BankAccount` struct. * Use `std::thread::sleep` to simulate delays between transactions. **Submission:** -------------- Please submit your code solution to the practical exercise above. **Additional Resources:** ------------------------- * [Rust Concurrency Book](https://ncameron.org/blog/rust-concurrency-book/) * [Tokio Crate Documentation](https://docs.rs/tokio/1.20.0/tokio/index.html) * [Rust Async/Await Guide](https://rust-lang.github.io/async-book/) **Leave a Comment/Ask for Help:** ------------------------------ If you have any questions or need help with the lab exercise, please leave a comment below. **Next Topic:** ---------------- In the next topic, we will cover "Understanding Rust's collection types: HashMap, BTreeMap, etc." from the section "Collections and Iterators".