Rust: Concurrent Programming in Rust

use std::thread;
use std::sync::mpsc;
use std::sync::{Arc, Mutex};
use std::time::Duration;

fn main() {
    // Create a document with shared content(Arc<Mutex<String>>)
    let document = Arc::new(Mutex::new(String::from("# Collaborative Documents\n\n")));

    // Create a channel,Used to transmit edit requests
    let (tx, rx) = mpsc::channel::<String>();

    // Receiving Thread:Processing editing requests on an ongoing basis
    let doc_for_receiver = Arc::clone(&document);
    let receiver = thread::spawn(move || {
        for edit in rx {
            let mut doc = doc_for_receiver.lock().unwrap();
            doc.push_str(&edit);
            doc.push('\n');
            println!("[Receiver] Edits Applied");
        }
    });

    // Simulating an Editor Thread
    let tx1 = tx.clone();
    thread::spawn(move || {
        tx1.send("- Alice: Added the content for Chapter 1".to_string()).unwrap();
    });

    let tx2 = tx.clone();
    thread::spawn(move || {
        tx2.send("- Bob: The title of Chapter 2 has been revised.".to_string()).unwrap();
    });

    // The main thread also sends a message
    tx.send("- Luna: Format Adjustments".to_string()).unwrap();

    // Wait until all editors have finished sending their edits
    thread::sleep(Duration::from_millis(100));
    drop(tx);  // Close the sender

    receiver.join().unwrap();

    // Final Document Content
    let final_doc = document.lock().unwrap();
    println!("\n=== Final Document ===");
    println!("{}", *final_doc);
}

=== Kitchen Renovation Begins ===
[Chef A] Chopping vegetables... Cut #<i>
[Chef B] Stir-frying... Step #<i>
[Head Chef] Plating in progress... Item #<i>

=== Kitchen Shutdown ===
Chef A: <result1>
Chef B: <result2>
All work has been completed!

// ============================================
// Demo:thread::spawn Create a Thread、join The Wait Is Over
// Simulation: Several chefs are preparing different dishes at the same time in the kitchen.
// ============================================

use std::thread;
use std::time::Duration;

fn main() {
    println!("=== Kitchen Renovation Begins ===");

    // --- 1. Create three threads to perform different tasks ---
    let chef1 = thread::spawn(|| {
        for i in 1..=3 {
            println!("[Chef A] Chopping vegetables... Cut #{}", i);
            thread::sleep(Duration::from_millis(50));
        }
        "A Finished chopping the vegetables"
    });

    let chef2 = thread::spawn(|| {
        for i in 1..=3 {
            println!("[Chef B] Stir-frying... Step #{}", i);
            thread::sleep(Duration::from_millis(40));
        }
        "B Finished cooking the stir-fry"
    });

    // The main thread is also running
    for i in 1..=3 {
        println!("[Head Chef] Plating in progress... Item #{}", i);
        thread::sleep(Duration::from_millis(60));
    }

    // --- 2. join Wait for all threads to finish and retrieve the return values ---
    let result1 = chef1.join().unwrap();
    let result2 = chef2.join().unwrap();

    println!("\n=== Kitchen Shutdown ===");
    println!("Chef A: {}", result1);
    println!("Chef B: {}", result2);
    println!("All work has been completed!");
}

=== Kitchen Renovation Begins ===
[Chef A] Chopping vegetables... Cut #1
[Chef B] Stir-frying... Step #1
[Head Chef] Plating in progress... Item #1
[Chef A] Chopping vegetables... Cut #2
[Chef B] Stir-frying... Step #2
[Head Chef] Plating in progress... Item #2
[Chef A] Chopping vegetables... Cut #3
[Chef B] Stir-frying... Step #3
[Head Chef] Plating in progress... Item #3

=== Kitchen Shutdown ===
Chef A: A Finished chopping the vegetables
Chef B: B Finished cooking the stir-fry
All work has been completed!

=== Collaborative Document Editor ===
[Server] <user> Inserted: <text>
[Server] <user> Deleted line <line>
[Server] <user> Formatting has been applied: <style>
[Server] Passage Closed,Unsubscribe
All editors have completed their work
=== End of editing session ===

// ============================================
// Demo: mpsc::channel Many-Producer, Single-Consumer Messaging
// Simulation: Multiple editors send modification requests to the document server
// ============================================

use std::thread;
use std::sync::mpsc;
use std::time::Duration;

#[derive(Debug)]
enum EditAction {
    Insert { user: String, text: String },
    Delete { user: String, line: u32 },
    Format { user: String, style: String },
}

fn main() {
    println!("=== Collaborative Document Editor ===");

    // Create a Channel:Sender Can be cloned,Receiver It is the only one
    let (tx, rx) = mpsc::channel::<EditAction>();

    // --- 1. Start the receive thread (Document Server) ---
    let receiver = thread::spawn(move || {
        for action in rx {
            match &action {
                EditAction::Insert { user, text } => {
                    println!("[Server] {} Inserted: {}", user, text);
                }
                EditAction::Delete { user, line } => {
                    println!("[Server] {} Deleted line {}", user, line);
                }
                EditAction::Format { user, style } => {
                    println!("[Server] {} Formatting has been applied: {}", user, style);
                }
            }
            // Simulated Processing Time
            thread::sleep(Duration::from_millis(20));
        }
        println!("[Server] Passage Closed,Unsubscribe");
    });

    // --- 2. Create the first editor thread (Alice) ---
    let tx1 = tx.clone();
    let editor1 = thread::spawn(move || {
        tx1.send(EditAction::Insert {
            user: "Alice".to_string(),
            text: "Chapter 1: Rust Introduction".to_string(),
        }).unwrap();
        thread::sleep(Duration::from_millis(10));
        tx1.send(EditAction::Format {
            user: "Alice".to_string(),
            style: "Bold the title".to_string(),
        }).unwrap();
    });

    // --- 3. Create the second editor thread (Bob) ---
    let tx2 = tx.clone();
    let editor2 = thread::spawn(move || {
        tx2.send(EditAction::Insert {
            user: "Bob".to_string(),
            text: "Rust is a systems programming language".to_string(),
        }).unwrap();
        thread::sleep(Duration::from_millis(10));
        tx2.send(EditAction::Delete {
            user: "Bob".to_string(),
            line: 1,
        }).unwrap();
    });

    // --- 4. The main thread also sends a message ---
    tx.send(EditAction::Insert {
        user: "System".to_string(),
        text: "Auto-Save Documents".to_string(),
    }).unwrap();

    // Wait for the editor thread to finish
    editor1.join().unwrap();
    editor2.join().unwrap();

    // Close the sender - After all Senders are dropped, the Receiver for loop will end automatically
    // tx is dropped here (because tx is the last sender on the main thread)

    println!("All editors have completed their work");
    receiver.join().unwrap();
    println!("=== End of editing session ===");
}
// Note: tx is automatically dropped when leaving the scope, channel closes
// If you need to explicitly turn it off,Can be used drop(tx)

=== Collaborative Document Editor ===
[Server] System Inserted: Auto-Save Documents
[Server] Alice Inserted: Chapter 1: Rust Introduction
[Server] Bob Inserted: Rust is a systems programming language
[Server] Alice Formatting has been applied: Bold the title
[Server] Bob Deleted line 1
All editors have completed their work
[Server] Passage Closed,Unsubscribe
=== End of editing session ===

=== Shared Counter Demo ===
[Workers<id>] Current Count: <*num>
[Workers<id>] Work Completed

=== Final Results ===
Final counter value: <*final_count>
Expected value: 50 (5 threads x 10 times)

// ============================================
// Demo: Arc<Mutex<T>> Safely Sharing Data Among Multiple Threads
// Simulation: Multiple workers modifying a shared counter simultaneously
// ============================================

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

fn main() {
    println!("=== Shared Counter Demo ===");

    // Use Arc<Mutex<i32>> to wrap shared data
    let counter = Arc::new(Mutex::new(0i32));
    let mut handles = vec![];

    // --- Start 5 threads,Each thread increments the counter by 10 ---
    for id in 0..5 {
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            for _ in 0..10 {
                // lock() Acquire a mutex lock——If the lock is held by another thread,The current thread will block while waiting
                let mut num = counter_clone.lock().unwrap();
                *num += 1;
                println!("[Workers{}] Current Count: {}", id, *num);
                // Locks are automatically released when they go out of scope
            }
            println!("[Workers{}] Work Completed", id);
        });
        handles.push(handle);
    }

    // --- Wait for all threads to finish ---
    for handle in handles {
        handle.join().unwrap();
    }

    // --- Read the final results ---
    let final_count = counter.lock().unwrap();
    println!("\n=== Final Results ===");
    println!("Final counter value: {}", *final_count);
    println!("Expected value: {} (5 threads x 10 times)", 5 * 10);
}

=== Shared Counter Demo ===
[Workers0] Current Count: 1
[Workers0] Current Count: 2
[Workers1] Current Count: 3
[Workers1] Current Count: 4
[Workers0] Current Count: 5
... (The intermediate output varies depending on thread scheduling)
[Workers4] Current Count: 50
[Workers4] Work Completed

=== Final Results ===
Final counter value: 50
Expected value: 50 (5 threads x 10 times)

Producer1 Done
Producer2 Done
=== Consumer Receipt ===
  Received: <msg>
All producers have finished, consumer section ended

// ============================================
// Producer-Consumer: Multiple producers + Single consumer
// ============================================

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();
    let tx2 = tx.clone();

    thread::spawn(move || {
        let items = vec!["Apple", "Banana", "Orange"];
        for item in items {
            tx.send(format!("Producer1: {}", item)).unwrap();
            thread::sleep(Duration::from_millis(100));
        }
        println!("Producer1 Done");
    });

    thread::spawn(move || {
        let items = vec!["Watermelon", "Grapes"];
        for item in items {
            tx2.send(format!("Producer2: {}", item)).unwrap();
            thread::sleep(Duration::from_millis(150));
        }
        println!("Producer2 Done");
    });

    println!("=== Consumer Receipt ===");
    for msg in rx {
        println!("  Received: {}", msg);
    }
    println!("All producers have finished, consumer section ended");
}

=== Consumer Receipt ===
  Received: Producer1: Apple
  Received: Producer2: Watermelon
  Received: Producer1: Banana
  Received: Producer1: Orange
  Received: Producer2: Grapes
Producer1 Done
Producer2 Done
All producers have finished, consumer section ended

The various thread sections and: <partials>
=== Serial Summation ===
1 to 1000 sum: <sequential_sum>

=== Parallel Summation (4 Thread) ===
Parallel Summation Results: <parallel_result>

=== 10M Data Performance Comparison ===
Serial: <seq_time>
Parallel (8Thread): <par_time>

// ============================================
// Parallel Computing: Multithreaded Sharded Summation
// ============================================

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

fn parallel_sum(data: &[i64], num_threads: usize) -> i64 {
    let chunk_size = (data.len() + num_threads - 1) / num_threads;
    let result = Arc::new(Mutex::new(0i64));
    let mut handles = Vec::new();

    for i in 0..num_threads {
        let chunk = data[i * chunk_size..(i * chunk_size + chunk_size).min(data.len())].to_vec();
        let result = Arc::clone(&result);
        handles.push(thread::spawn(move || {
            let partial: i64 = chunk.iter().sum();
            *result.lock().unwrap() += partial;
            partial
        }));
    }

    let mut partials = Vec::new();
    for handle in handles {
        partials.push(handle.join().unwrap());
    }

    println!("The various thread sections and: {:?}", partials);
    *result.lock().unwrap()
}

fn main() {
    let data: Vec<i64> = (1..=1000).collect();
    let sequential_sum: i64 = data.iter().sum();

    println!("=== Serial Summation ===");
    println!("1 to 1000 sum: {}", sequential_sum);

    println!("\n=== Parallel Summation (4 Thread) ===");
    let parallel_result = parallel_sum(&data, 4);
    println!("Parallel Summation Results: {}", parallel_result);
    assert_eq!(sequential_sum, parallel_result);

    let data2: Vec<i64> = (1..=10_000_000).collect();
    let start = std::time::Instant::now();
    let _ = data2.iter().sum::<i64>();
    let seq_time = start.elapsed();

    let start = std::time::Instant::now();
    let _ = parallel_sum(&data2, 8);
    let par_time = start.elapsed();

    println!("\n=== 10M Data Performance Comparison ===");
    println!("Serial: {:?}", seq_time);
    println!("Parallel (8Thread): {:?}", par_time);
}

=== Serial Summation ===
1 to 1000 sum: 500500

=== Parallel Summation (4 Thread) ===
The various thread sections and: [78126, 218874, 109374, 94126]
Parallel Summation Results: 500500

=== 10M Data Performance Comparison ===
Serial: [Time]
Parallel (8Thread): [Time]