Rust provides powerful tools for concurrent and parallel programming, enabling you to build highly performant applications. Concurrency refers to the ability of a program to handle multiple tasks seemingly at the same time, while parallelism involves physically executing those tasks simultaneously on multiple cores. Rust's ownership and borrowing system ensures thread safety, significantly reducing the risk of data races and other concurrency-related bugs. This lesson builds on previous knowledge of threads, exploring more sophisticated concurrency patterns. Recall that threads are lightweight and cheap to create, allowing us to perform operations independently and in parallel.

The actor model is a concurrency model where computations are performed by independent actors that communicate via message passing. Each actor has its own state and a mailbox (or channel) for receiving messages. Let's create a simple actor system to sum a list of numbers.

use std::sync::mpsc::{channel, Sender, Receiver};
use std::thread;

struct Actor {
    receiver: Receiver<Message>,
}

enum Message {
    Add(i32),
    GetResult(Sender<i32>),
}

impl Actor {
    fn new(receiver: Receiver<Message>) -> Self {
        Actor { receiver }
    }

    fn run(&self) {
        let mut sum = 0;
        loop {
            match self.receiver.recv() {
                Ok(message) => {
                    match message {
                        Message::Add(value) => sum += value,
                        Message::GetResult(sender) => {
                            sender.send(sum).unwrap();
                        }
                    }
                }
                Err(_) => break,
            }
        }
    }
}

fn main() {
    let (sender, receiver) = channel();
    let actor = Actor::new(receiver);
    let handle = thread::spawn(move || {
        actor.run();
    });

    let (result_sender, result_receiver) = channel();

    // Send some messages
    for i in 1..=5 {
        sender.send(Message::Add(i)).unwrap();
    }

    // Get the result
    sender.send(Message::GetResult(result_sender)).unwrap();

    let result = result_receiver.recv().unwrap();
    println!("Sum: {}", result);

    drop(sender); // Signals to the actor that we are done.
    handle.join().unwrap();
}

In this example, the Actor struct encapsulates the actor's behavior. The main function creates the actor, sends messages, and receives the final result. The channel is used as the mailbox. The drop(sender) allows the actor.run() loop to exit when all senders close.

Rust's channels are the primary mechanism for communication between threads. The mpsc (multi-producer, single-consumer) channel is suitable for scenarios where multiple threads need to send messages to a single receiver. The oneshot channel provides a single-send, single-receive communication pattern.

use std::sync::mpsc::{channel, Sender, Receiver};
use std::thread;

fn main() {
    // MPSC Channel
    let (tx, rx): (Sender<i32>, Receiver<i32>) = channel();

    thread::spawn(move || {
        tx.send(10).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Received: {}", received);

    // Oneshot channel
    use std::sync::mpsc::sync_channel;
    let (tx_oneshot, rx_oneshot) = sync_channel(0); // non-buffered channels
    thread::spawn(move || {
        tx_oneshot.send(String::from("Hello from oneshot!")).unwrap();
    });

    let received_oneshot = rx_oneshot.recv().unwrap();
    println!("Received oneshot: {}", received_oneshot);
}

sync_channel(0) creates a channel where the sender will block until the receiver is ready. sync_channel(buffer_size) creates a channel that supports buffered messages.

When multiple threads need to access and modify shared data, you must use synchronization primitives to prevent data races. The most common primitive is a Mutex (mutual exclusion lock).

use std::sync::{Mutex, Arc};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

In this example, Arc (atomic reference counted) allows us to safely share the Mutex across multiple threads. The lock() method acquires the mutex, and unwrap() handles potential errors (e.g., if another thread panics while holding the lock). Other synchronization primitives include RwLock (read-write lock) and Condvar (condition variable). Be mindful of deadlock situations when using multiple locks.

Beyond Mutexes, Rust offers more sophisticated tools for concurrent programming. Atomic variables (e.g., AtomicI32) provide lock-free access to primitive types, which can offer significant performance improvements in high-contention scenarios. RwLock (Read-Write Lock) allows multiple readers or a single writer access to shared data. Condition variables allow threads to wait for a specific condition to become true. The parking_lot crate provides alternative, performance-focused implementations of synchronization primitives. Selecting the appropriate synchronization technique is crucial for optimizing the performance and reliability of concurrent applications.