Rust 并发

Rust 第25节 并发

并发

thread::spawn() 创建新线程

参数是一个闭包,新线程执行的代码

rust 复制代码
fn main() {


    thread::spawn(||{
        for i in 1..10 {
            println!("son thread run :{}",i);
            thread::sleep(Duration::from_micros(1));
        }
    });

    for i in 1..5 {
        println!("main thread run :{}",i);
        thread::sleep(Duration::from_micros(1));
    }
}

当主线程结束时,不管其他子线程是否结束,都会结束所有的子线程

可以使用 join()方法,等待子线程执行完

thread::spawn()会返回 joint_handler

move 闭包

从一个线程中,将所有权转移到另一个线程中

rust 复制代码
    let v = vec![11,13,14];

    let handler = thread::spawn(move ||{  //将v的所有权移动到新线程中

        println!("{:?}",v);
    });

    handler.join().unwrap();

使用消息传递来跨线程传递数据

channel

mpsc ::channel(多个生产者,一个消费者)

返回一个元组 发送端和接收端

rust 复制代码
    let (tx,rx) = mpsc::channel();
    thread::spawn(move || {
        let val = String::from("hello");
        tx.send(val).unwrap();
    });

    let recv = rx.recv().unwrap();

    println!("main recved:{}",recv);

发送端的send方法

参数:想要发送的数据

返回值:Result<T,E>

如果有问题,就返回一个错误

接收端的方法:

recv:阻止当前线程执行,直到Channel中有值被送过来

有值返回Result<T,E>

通道关闭,返回错误

try_recv方法 不会阻塞,立即返回,有数据,返回OK,否则返回错误

所有权

发送后,数据的所有权已经转移

发送多条消息

rust 复制代码
    let (tx,rx) = mpsc::channel();

    thread::spawn(move || {
        let v = vec![String::from("message"),
                                    String::from("from"),
                                    String::from("thread"),
        ];

        for i in v {
            tx.send(i).unwrap();
            thread::sleep(Duration::from_micros(1));
        }
    });


    for receive in rx {  //可以直接循环
        println!("Get: {}",receive);
    }

通过clone复制多个发送者

rust 复制代码
    let (tx,rx) = mpsc::channel();

    let tx2 = mpsc::Sender::clone(&tx);
    thread::spawn(move || {
        let v = vec![String::from("1: message"),
                                    String::from("1: from"),
                                    String::from("1: thread"),
        ];

        for i in v {
            tx.send(i).unwrap();
            thread::sleep(Duration::from_micros(1));
        }
    });



    thread::spawn(move || {
        let v = vec![String::from("2: message"),
                                    String::from("2: from"),
                                    String::from("2: thread"),
        ];

        for i in v {
            tx2.send(i).unwrap();
            thread::sleep(Duration::from_micros(1));
        }
    });


    for receive in rx {
        println!("Get: {}",receive);
    }

使用共享内存进行并发

使用mutex来每次只允许一个线程访问数据

mutex::new(数据) 来创建 mutex,他也是一个智能指针

在访问数据前,通过lock方法来获取锁

rust 复制代码
    let m = Mutex::new(5);
    {
        let mut num = m.lock().unwrap();//线程会阻塞到这里,直到获取到锁
        *num = 6;
    }

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

多重所有权

想让多个线程都能使用mutex,需要将mutex的所有权进行多重多有权

并发使用的多重所有权为Arc,他和Rc的API完全一样

Arc是实现了原子级别的计数

Send 和 Sync trait

send :允许线程间转移所有权

sync : 允许多线程访问

手动实现这两个trait是无法保证安全的。

相关推荐
满怀10153 分钟前
Python入门(5):异常处理
开发语言·python
攀小黑7 分钟前
Java 多线程加锁 synchronized 关键字 字符串当做key
java·开发语言
每次的天空16 分钟前
Kotlin 作用域函数:apply、let、run、with、also
android·开发语言·kotlin
小林熬夜学编程20 分钟前
【高并发内存池】第八弹---脱离new的定长内存池与多线程malloc测试
c语言·开发语言·数据结构·c++·算法·哈希算法
MariaH23 分钟前
Sequelize模型初探
前端·后端
码视野24 分钟前
基于SpringBoot的河道水情大数据可视化分析平台设计与实现(源码+论文+部署讲解等)
spring boot·后端·物联网·信息可视化·论文·本科毕业论文·计算机专业毕业论文
你的人类朋友28 分钟前
解释一下Node.js的『阻塞』现象,并回答:为什么会阻塞?什么情况下会阻塞?
javascript·后端·node.js
dony724729 分钟前
MCP 接入使用总结(面向开发人员)
后端·mcp
京东零售技术30 分钟前
One4All下一代生成式推荐系统
后端
独好紫罗兰31 分钟前
洛谷题单3-P1980 [NOIP 2013 普及组] 计数问题-python-流程图重构
开发语言·python·算法