【作业打卡】Week5. 模块五：并发编程和异步编程

[bonnie0519]

1. 如何理解 Rust 中的并发编程和异步编程？
2. 尝试编写一个并发程序
3. 使用社区中你喜欢的异步运行时编写一个小程序

[Insomnia501]

如何理解 Rust 中的并发编程和异步编程？

并发：一个内核交替处理多个任务，由操作系统来切换线程

异步：发生在1个线程内，避免切换线程。异步任务在等待IO操作时可以挂起，不需要占用线程；当IO操作完成时，异步任务可以继续执行。

尝试编写一个并发程序

以下程序创建两个线程，每个线程并发执行10个子任务

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

fn main() {
    let handle1 = thread::spawn(|| {
        for i in 1..10 {
            println!("Thread 1 count: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    let handle2 = thread::spawn(|| {
        for i in 1..10 {
            println!("Thread 2 count: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
}

使用社区中你喜欢的异步运行时编写一个小程序

以下程序创建两个异步任务，每个任务都会休眠一段时间并print一些信息

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    let sleep_task = tokio::spawn(async {
        sleep(Duration::from_secs(5)).await;
        println!("After 5 seconds!");
    });

    let other_task = tokio::spawn(async {
        sleep(Duration::from_secs(2)).await;
        println!("After 2 seconds!");
    });

    sleep_task.await.unwrap();
    other_task.await.unwrap();
}

[v1xingyue]

1. 如何理解 Rust 中的并发编程和异步编程？

单说，并发指的是，将不同的任务拆分成两条线。
向这两条任务线共同分配时间，因为，时间切换时间极短，所以感觉上是任务同时在执行。
在rust 中这个任务线被实现为操作系统的线程。
在多核CPU 架构下，两条任务线可以认为是分配在不同的cpu核心上，某种程度上也可以认为任务并行。

异步编程:
异步操作一般用于相对耗时的等待。
等待的间隔，将任务挂起，并记录任务现场，去执行其他的任务。
当等待完成后，切换回 任务挂起的地方。

再编程中，多体现为事件回调机制。
rust 中的异步操作为 async ， await 标记。这个和 Javvascript 中的 Promise 类似。
其使用机制也很类似。

2. 实现一个 并发代码逻辑

以下是一个并发产生账号的代码。

线程对象存储到 handlers 中，用于主线程的等待。
同时，有一个共享资源对象 accounts , 被封装到一个 Arc 中，用于每个线程生成账号后，写入。

    let mut handlers = vec![];
    let accounts = vec![];

    let accounts_arc: Arc<Mutex<Vec<SuiAccount>>> = Arc::new(Mutex::new(accounts));

    for thread_no in 1..=3 {
        let handle_resource = Arc::clone(&accounts_arc);
        let handle = thread::spawn(move || {
            for i in 1..=5 {
                let account: SuiAccount = SuiAccount::new_account();
                println!(
                    "thread {:0>4} create account  No.{:0>3} {}",
                    thread_no, i, account
                );
                let mut _guard = handle_resource.lock().unwrap();
                _guard.push(account);
            }
        });
        handlers.push(handle);
    }

    for handler in handlers {
        handler.join().unwrap();
    }

.3. 异步操作代码:

async 声明为异步方法。
内部使用 await 等待其他的异步操作 ， 以下实例为 network.get_object_id

#[tokio::main]
async fn main() {
    let network = network();
    let object_id = "0x2dfc31f14cc8b0040407e818568fa37e95e52281b684b67050ab32a16942d955";
    println!("gateway is : {}", network.get_gateway());
    println!("network is : {}", network);
    println!("object link is : {} ", network.object_link(object_id));
    network.get_object_id(object_id).await;
}
``

[jiantao88]

如何理解 Rust 中的并发编程和异步编程？

并发编程 是指在单个程序中同时进行多个任务。这是通过在程序中创建并使用线程来完成的。每个线程可以并行（如果系统有多个处理器）或者并发地（如果系统只有一个处理器）执行任务。使用 std::thread 模块来创建多个线程，并让它们同时执行不同的任务。Rust 的线程模型保证了线程之间的内存安全和数据竞争的检查。

异步编程 是一种编程范式，它通过允许任务延迟完成以释放系统资源来提高性能和响应性。在 Rust 中，异步编程通常用于 I/O 操作，如网络或磁盘操作。Rust 的异步编程模型依赖于 Futures 和 async/await 语法。Future 是一个可以在将来某个时刻完成的任务，它返回一个结果或错误。async/await 语法是构建和管理这些 Futures 的一种方式。

尝试编写一个并发程序

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

fn main() {
    let handles: Vec<_> = (0..10).map(|i| {
        thread::spawn(move || {
            // 模拟一些计算工作
            thread::sleep(Duration::from_millis(i * 100));
            println!("Thread {} has finished.", i);
        })
    }).collect();

    // 等待所有线程完成
    for handle in handles {
        handle.join().unwrap();
    }

    println!("All threads have finished.");
}

使用社区中你喜欢的异步运行时编写一个小程序

https://github.com/jiantao88/caipiao

[lx7575000]

1. 如何理解 Rust 中的并发编程和异步编程？

• 并发编程，是指在同一时间段内执行多个独立的任务或操作。在并发编程中，这些任务可以在时间上交替执行，每个任务独立运行，彼此之间无需等待。Rust 提供了多线程编程的能力，可以使用 Rust 的标准库或第三方库来创建多个线程，并让这些线程并发地执行任务。在多线程并发编程中，你可以使用锁、原子操作等机制来确保对共享数据的安全访问和同步。

• 异步编程，是一种编程模型，它允许你在执行 I/O 操作时不会阻塞其他任务的执行。异步编程通过将任务划分为小的异步操作，并使用非阻塞的方式执行这些操作，以充分利用 CPU 时间，同时避免线程的阻塞等待。Rust 提供了异步编程的支持，通过使用异步运行时库（如 Tokio 或 async-std），可以使用异步函数、Future 和 async/await 语法来编写异步代码。异步编程允许处理大量并发的任务，同时提供良好的性能和资源利用率。

2. 尝试编写一个并发程序

// 通过Arc和Mutex实现多线程数据共享
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    // Mutex Lock
    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 count = counter.lock().unwrap();
            *count += 1;
        });
        handles.push(handle);
    }
    for handle in handles {
        handle.join().unwrap();
    }

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

3. 使用社区中你喜欢的异步运行时编写一个小程序

use tokio::time::{sleep, Duration};

async fn async_task() {
    println!("异步任务： start");

    // 模拟异步操作，这里使用 sleep 来模拟耗时操作
    sleep(Duration::from_secs(2)).await;

    println!("异步任务：end");
}

#[tokio::main]
async fn main() {
    println!("主程序 start");

    // 创建异步任务并等待其完成
    let task = async_task();
    task.await;

    println!("主程序 end");
}

[walle233]

1. 在Rust中，并发编程是指同时执行多个任务，通过分配CPU时间片来实现任务间的并行执行。Rust提供了并发编程的原语，如线程、原子操作、互斥锁和通道等，用于实现多线程编程。通过使用这些原语，开发者可以编写高效且安全的并发程序。

异步编程是一种基于事件驱动的编程模型，其中任务的执行不会阻塞主线程或其他任务的执行。Rust提供了异步编程的支持，通过async/await语法和异步运行时来实现。异步编程可以提高程序的性能，特别适用于I/O密集型的任务，如网络请求、文件操作等。Rust的异步编程模型借鉴了Async/Await模式，使得编写异步代码更加直观和易于理解。

2. 这是一个示例的并发程序，使用Rust中的线程来并行执行两个任务：

use std::thread;

fn main() {
    let handle1 = thread::spawn(|| {
        for i in 1..=5 {
            println!("Task 1: {}", i);
            thread::sleep_ms(1000); // 模拟耗时操作
        }
    });

    let handle2 = thread::spawn(|| {
        for i in 1..=5 {
            println!("Task 2: {}", i);
            thread::sleep_ms(1000); // 模拟耗时操作
        }
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
}

在这个示例中，我们使用thread::spawn函数创建了两个线程，每个线程执行一个任务。任务使用for循环打印一系列数字，并通过thread::sleep_ms函数模拟了一个耗时操作。主线程通过调用join方法等待子线程的结束。

3. 这是一个使用tokio异步运行时的简单示例程序：

use tokio::time::{sleep, Duration};

async fn do_something_async() {
    println!("Async task started");
    sleep(Duration::from_secs(2)).await;
    println!("Async task completed");
}

#[tokio::main]
async fn main() {
    println!("Main task started");
    do_something_async().await;
    println!("Main task completed");
}

在这个示例中，我们使用tokio异步运行时的宏标记了main函数，并在其中调用了do_something_async异步函数。异步函数使用async关键字标记，并在函数内部通过await关键字等待一个异步任务完成。在main函数中，我们先打印一条开始消息，然后调用异步函数，并用await等待它的完成。最后打印一条完成消息。运行这个程序将会看到异步任务和主任务是同时执行的。

[laughinglky]

1、如何理解Rust中的并发编程和异步编程？
并发编程是指代码同时执行多个任务的能力，这些任务可以在同一时间段内交替执行，也可以同时执行。在Rust 中，可以使用线程作为并发编程的基本单位。
异步编程是指代码在等待某些操作完成时可以执行其他操作的能力。
2、尝试编写一个并发程序

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

fn main() {
    // 创建共享变量
    let sum = Arc::new(Mutex::new(0));

    // 创建4个线程，每个线程计算250个整数的和
    let mut handles = vec![];
    for i in 0..4 {
        let sum_clone = sum.clone();
        let handle = thread::spawn(move || {
            let mut local_sum = 0;
            for j in ((i * 250) + 1)..((i + 1) * 250 + 1) {
                local_sum += j;
            }
            let mut sum = sum_clone.lock().unwrap();
            *sum += local_sum;
        });
        handles.push(handle);
    }

    // 等待所有线程完成
    for handle in handles {
        handle.join().unwrap();
    }

    // 输出结果
    let sum = sum.lock().unwrap();
    println!("Sum: {}", *sum);
}

3、使用社区中你喜欢的异步运行时编写一个小程序

use async_std::io::{self, BufReader};
use async_std::prelude::*;

async fn echo() -> io::Result<()> {
    let mut reader = BufReader::new(io::stdin());
    let mut line = String::new();

    loop {
        line.clear();
        let n = reader.read_line(&mut line).await?;
        if n == 0 {
            break;
        }
        io::stdout().write_all(line.as_bytes()).await?;
    }

    Ok(())
}

fn main() -> io::Result<()> {
    async_std::task::block_on(async {
        echo().await
    })
}

[coderonion]

1. 如何理解 Rust 中的并发编程和异步编程？

并发编程和异步编程是处理并行执行任务和处理异步事件的两种重要方式。
1）并发编程是指同时执行多个任务或操作的能力。在并发编程中，任务可以是独立的，彼此之间没有依赖关系，可以并行执行以提高效率。
2）异步编程是指在遇到潜在的长时间操作时，不会阻塞当前线程，而是继续执行其他任务，待操作完成后再处理结果。在异步编程中，通常使用 Future 和 async/await 语法来处理异步任务。Rust 使用 async/await 语法结合 async_std、tokio 或其他异步运行时库来实现异步编程。

2. 尝试编写一个并发程序

use std::thread;

fn main() {
    
    
    let handle1 = thread::spawn(|| {
        for i in 1..=5 {
            println!("Thread 1: {}", i);
            thread::sleep(std::time::Duration::from_millis(500));
        }
    });

    let handle2 = thread::spawn(|| {
        for i in 1..=5 {
            println!("Thread 2: {}", i);
            thread::sleep(std::time::Duration::from_millis(500));
        }
    });

    let handle3 = thread::spawn(|| {
        for i in 1..=5 {
            println!("Thread 2: {}", i);
            thread::sleep(std::time::Duration::from_millis(500));
        }
    });
    
    handle1.join().unwrap();
    handle2.join().unwrap();
    handle3.join().unwrap();
}

3. 使用社区中你喜欢的异步运行时编写一个小程序

使用 tokio 进行异步文件读取示例：

use tokio::fs::File;
use tokio::io::{self, AsyncReadExt};

#[tokio::main]
async fn main() -> io::Result<()> {
    let file_path = "path/to/file.txt";

    let mut file = File::open(file_path).await?;
    let mut buffer = Vec::new();

    file.read_to_end(&mut buffer).await?;

    // 打印文件内容
    println!("File Content: {:?}", buffer);

    Ok(())
}