Rust 并发

这篇具有很好参考价值的文章主要介绍了Rust 并发。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Rust 第25节 并发

并发

thread::spawn() 创建新线程

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

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 闭包

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

    let v = vec![11,13,14];

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

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

    handler.join().unwrap();

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

channel

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

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

    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,否则返回错误

所有权

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

发送多条消息

    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复制多个发送者

    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方法来获取锁

    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是无法保证安全的。文章来源地址https://www.toymoban.com/news/detail-818533.html

到了这里,关于Rust 并发的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Rust 基础篇】Rust 多线程:并发编程的艺术

    多线程是现代计算机编程中的重要概念,它允许程序同时执行多个任务,充分利用多核处理器的性能优势。在 Rust 中,多线程编程也得到了很好的支持,通过标准库提供的 std::thread 模块可以方便地创建和管理线程。本篇博客将详细介绍 Rust 中多线程的使用方法,包含代码示例

    2024年02月16日
    浏览(43)
  • 【Rust 指南】并发编程|无畏并发的原因

       安全高效的处理并发是 Rust 诞生的目的之一,主要解决的是服务器高负载承受能力。 并发 ( concurrent )的概念是指程序不同的部分 独立执行 ,这与 并行 ( parallel )的概念容易混淆,并行强调的是\\\"

    2023年04月08日
    浏览(41)
  • Rust 并发

    thread::spawn() 创建新线程 参数是一个闭包,新线程执行的代码 当主线程结束时,不管其他子线程是否结束,都会结束所有的子线程 可以使用 join()方法,等待子线程执行完 thread::spawn()会返回 joint_handler 从一个线程中,将所有权转移到另一个线程中 channel mpsc ::channel(多个生产者

    2024年01月23日
    浏览(24)
  • Rust基础拾遗--并发和异步编程

       通过 Rust程序设计-第二版 笔记的形式对Rust相关 重点知识 进行汇总,读者通读此系列文章就可以轻松的把该语言基础捡起来。 为什么一些看似正确的多线程惯用法却根本不起作用? 与“内存模型”有关 你最终会找到一种自己用起来顺手且不会经常出错的并发惯用法。

    2024年02月19日
    浏览(35)
  • rust实践-异步并发socket通信

    String::from_utf8_lossy() 函数将字节数组转换为字符串 接受一个字节数组作为参数,并尝试将其转换为 UTF-8 编码的字符串 如果字节数组包含无效的 UTF-8 字符,则这些字符将被替换为问号 ? from_utf8_lossy() 函数返回一个 Cow 类型的对象 这个对象实现了 ToString trait 所以可以使用 to_s

    2024年02月13日
    浏览(34)
  • 没有synchronized,rust怎么防并发?

    学过Java的同学对synchronized肯定不陌生,那么rust里怎么办呢? 在Rust中,可以使用标准库提供的 std::sync::Mutex 来实现加锁功能。Mutex是互斥锁的一种实现,用于保护共享数据在并发访问时的安全性。 下面是一个简单的示例代码,展示了如何在Rust中使用Mutex进行加锁: 在上述代

    2024年02月13日
    浏览(30)
  • Rust并发编程实践:10分钟入门系统级编程

    目录 学前一问:Rust为何而出现? 摘要 引言 正文解析: 一、Rust中的并发编程基础 1.1 线程 1.2 协程 二、Rust并发编程的高级特性 2.1 通道 2.2 原子操作 2.3 锁 三、实例展示:优化并发编程性能 1. 并行计算 2. 异步IO 3. 数据并行 四、并发编程的挑战与最佳实践 结论: 参考文献:

    2024年04月26日
    浏览(35)
  • Rust 中 Actor 并发模型的实践与使用

    Actor 模型是一种并行计算模型,提供了一种用于构建并发、分布式系统的形象办法。在 Actor 模型中, 计算被示意为独立的、轻量级的计算单元,称为 Actor ,能够发送和接管音讯并进行本地计算。 作为一种通用的消息传递编程模型,被广泛用于构建大规模可伸缩分布式系统。

    2024年04月28日
    浏览(28)
  • 【跟小嘉学 Rust 编程】十六、无畏并发(Fearless Concurrency)

    【跟小嘉学 Rust 编程】一、Rust 编程基础 【跟小嘉学 Rust 编程】二、Rust 包管理工具使用 【跟小嘉学 Rust 编程】三、Rust 的基本程序概念 【跟小嘉学 Rust 编程】四、理解 Rust 的所有权概念 【跟小嘉学 Rust 编程】五、使用结构体关联结构化数据 【跟小嘉学 Rust 编程】六、枚举

    2024年02月11日
    浏览(38)
  • rust 自动化测试、迭代器与闭包、智能指针、无畏并发

    编写测试可以让我们的代码在后续迭代过程中不出现功能性缺陷问题;理解迭代器、闭包的函数式编程特性; BoxT 智能指针在堆上存储数据, RcT 智能指针开启多所有权模式等;理解并发,如何安全的使用线程,共享数据。 编写测试以方便我们在后续的迭代过程中,不会改坏

    2024年02月16日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包