Rust8.2 Fearless Concurrency 无畏并发

Rust学习笔记

Rust编程语言入门教程课程笔记

参考教材: The Rust Programming Language (by Steve Klabnik and Carol Nichols, with contributions from the Rust Community)

Lecture 16: Fearless Concurrency 无畏并发

src/main.rs

rust 复制代码
use std::thread;
use std::time::Duration;
use std::sync::mpsc;
use std::sync::{Mutex, Arc};

fn main() {
    //Using Threads to Run Code Simultaneously

    //Creating a New Thread with spawn
    
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
    // output:
    // hi number 1 from the main thread!
    // hi number 1 from the spawned thread!
    // hi number 2 from the main thread!
    // hi number 2 from the spawned thread!
    // hi number 3 from the main thread!
    // hi number 3 from the spawned thread!
    // hi number 4 from the main thread!
    // hi number 4 from the spawned thread!

    //In this run, the main thread printed first, 
    //even though the print statement from the spawned thread appears first in the code. 
    //And even though we told the spawned thread to print until i is 9, 
    //it only got to 5 before the main thread shut down.

    //Waiting for All Threads to Finish Using join Handles
    handle.join().unwrap();
    
    let v = vec![1, 2, 3];
    let handle = thread::spawn(move || {
        println!("Here's a vector: {:?}", v);
    });//move closure: v is moved into the closure

    // drop(v); // oh no! v is moved into the thread

    handle.join().unwrap();

    //Using Message Passing to Transfer Data Between Threads
    let (tx, rx) = mpsc::channel();
    thread::spawn(move || {
        let val = String::from("hi");
        // tx.send(val).unwrap();
        tx.send(val).unwrap();
        // println!("val is {}", val); // error: value borrowed here after move
    });

    let received = rx.recv().unwrap();//recv blocks the main thread's execution and waits until a value is sent down the channel
    println!("Got: {}", received);

    //try_recv: without blocking
    
    //Sending Multiple Values and Seeing the Receiver Waiting
    let (tx, rx) = mpsc::channel();
    thread::spawn(move || {
        let vals = vec![
            String::from("hello"),
            String::from("from"),
            String::from("the"),
            String::from("thread"),];
        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_secs(1));
        }
    });

    for received in rx {
        println!("Got: {}", received);
    }

    //Shared-State Concurrency
    //Mutexes: Mutual Exclusion
    //API: lock, unwrap, Mutex<T> (smart pointer)

    let m = Mutex::new(5);
    {
        let mut num = m.lock().unwrap();
        *num = 6;
        // println!("m is {}", m); // error: cannot be formatted with the default formatter
    }

    println!("m is {:?}", m);

    //Sharing a Mutex<T> Between Multiple Threads
    let counter = Arc::new(Mutex::new(0));
    //Arc<T> is an atomically reference counted type
    //A: atomically, R: reference, C: counted
    //API in Arc is the same as in Rc 


    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());//Result: 10

    //Extensible Concurrency with the Sync and Send Traits
    //Send: ownership can be transferred between threads
    //Sync: multiple threads can have references to the same value

    //Implementing Send and Sync Manually Is Unsafe
}
相关推荐
DES 仿真实践家3 分钟前
【Day 11-N22】Python类(3)——Python的继承性、多继承、方法重写
开发语言·笔记·python
芳草萋萋鹦鹉洲哦5 小时前
【vue3+tauri+rust】如何实现下载文件mac+windows
windows·macos·rust
IMPYLH6 小时前
Python 的内置函数 reversed
笔记·python
ysa05103010 小时前
数论基础知识和模板
数据结构·c++·笔记·算法
今天背单词了吗98010 小时前
算法学习笔记:7.Dijkstra 算法——从原理到实战,涵盖 LeetCode 与考研 408 例题
java·开发语言·数据结构·笔记·算法
mitt_11 小时前
《人生顶层设计》读书笔记7
笔记
智者知已应修善业11 小时前
【51单片机节日彩灯控制器设计】2022-6-11
c语言·经验分享·笔记·单片机·嵌入式硬件·51单片机
Jyywww12111 小时前
微信小程序学习笔记
笔记·学习·微信小程序
m0_6786933311 小时前
深度学习笔记29-RNN实现阿尔茨海默病诊断(Pytorch)
笔记·rnn·深度学习
sigmoidAndRELU12 小时前
读Vista
笔记·stable diffusion·世界模型