Rust学习第十四天——多线程同时运行代码

最新推荐文章于 2025-02-20 14:51:01 发布

星暖冷月

最新推荐文章于 2025-02-20 14:51:01 发布

阅读量980

点赞数 1

分类专栏： Rust 文章标签： rust 学习开发语言

本文链接：https://blog.youkuaiyun.com/yryryrkkx/article/details/128936750

版权

Rust 专栏收录该内容

14 篇文章

订阅专栏

并发

Concurrent：程序的不同部分之间独立的执行

Parallel：程序的不同部分同时运行

Rust无畏并发：允许你编写没有细微的Bug的代码，并在不引入新bug的情况下易于重构

使用线程同时运行代码

进程与线程

在大部分OS里，代码运行在进程（process）中，OS同时管理多个进程

在你的程序里，各独立部分可以同时运行，运行这些独立部分的就是线程

多线程运行：

提升性能表现

增加复杂性：无法保障各线程的执行顺序

多线程可导致的问题

竞争状态，线程以不一致的顺序访问数据或资源

死锁，两个线程彼此等待对方使用完所持有的资源，线程无法继续

只在某些情况下发生Bug，很难可靠的复制现象和修复

实现线程的方式

通过调用OS的API来创建线程：1:1模型

需要较小的运行时

语言自己实现的线程（绿色线程）：M:N模型

需要更大的运行时

Rust：需要先权衡运行时的支持

Rust标准库仅提供1:1模型的线程

通过spawn创建新线程

通过thread::spawn函数可以创建新线程：

参数：一个闭包（在新线程里运行的代码）

use std::{ thread, time::Duration };

fn main() {
    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));
    }
}

通过join Handle来等待所有线程的完成

thread::spawn函数的返回所有值类型时JoinHandle

JoinHandle持有值得所有权

调用join方法，可以等待对应的其他线程的完成

join方法：调用handle的join方法会阻止当前运行线程的执行，直到handle所表示的这些线程终结

加入：

use std::{ thread, time::Duration };

fn main() {
    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));
    }
    
    handle.join().unwrap();
}

使用Move闭包

move闭包通常和thread::spawn函数一起使用，它允许你使用其他线程的数据

创建线程时，把值的所有权从一个线程转移到另一个线程

use std::{ thread, time::Duration };

fn main() {
    let v = vec![1, 2, 3];
    let handle = thread::spawn(move || {
        println!("Here's a vector: {:?}", v);
    });

    handle.join().unwrap();
}

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

消息传递

一种很流行且能保证安全并发的技术就是：消息传递

线程（或Actor）通过彼此发送消息（数据）来进行通信

Go语言的名言：不要用共享内存来通信，要用通信来共享内存

Rust：Channel（标准库提供）

Channel

Channel包含：发送端、接收端

调用发送端的方法，发送数据

接收端会检查和接收到达的数据

如果发送端、接收端中任意一段被丢弃，那么Channel就“关闭”了

创建Channel

使用mpsc::channel函数来创建Channel

mpsc来表示multiple producer、single consumer

返回一个tuple（元组）：里面分别是发送端、接收端

（例子）

use std::{ thread, sync::mpsc };

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

    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Cot: {}", received);
}

发送端的send方法

参数：想要发送的数据

返回： Result<T, E>

如果有问题（例如接收端已经被丢弃），就返回一个错误

接收端的方法

recv方法：阻止当前线程的执行，直到Channel中有值被送来

一旦有值收到，就返回Result<T, E>

当发送端关闭，就会收到一个错误

try_recv方法：不会阻塞，

立即返回Result<T, E>:

有数据达到：返回OK，里面包含着数据

否则，返回错误

通常会使用循环调用来检查try_recv的结果

Channel和所有权转移

所有权在消息传递中非常重要：能帮你编写安全、并发的代码

发送多个值，看到接受者在等待

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

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

    thread::spawn(move || {
        let vals = vec![
            String::from("hi"),
            String::from("from"),
            String::from("the"),
            String::from("thread"),
        ];

        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_millis(1));
        }
    });

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

通过克隆创建多个发送者

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

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

    let tx1 = mpsc::Sender::clone(&tx);
    thread::spawn(move || {
        let vals = vec![
            String::from("1: hi"),
            String::from("1: from"),
            String::from("1: the"),
            String::from("1: thread"),
        ];

        for val in vals {
            tx1.send(val).unwrap();
            thread::sleep(Duration::from_millis(200));
        }
    });

    thread::spawn(move || {
        let vals = vec![
            String::from("hi"),
            String::from("from"),
            String::from("the"),
            String::from("thread"),
        ];

        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_millis(200));
        }
    });

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

共享状态的并发

使用共享来实现并发

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

Mutex时mutual exclusion（互斥锁）的简写

在同一时刻，Mutex只允许一个线程来访问某些数据

想要访问数据：

线程必须首先获取互斥锁（lock）

lock数据结构是mutex的一部分，它能跟踪谁对数据拥有独占访问权

Mutex通常被描述为：通过锁定系统来保护它所持有的的数据

Mutex的两条规则

Mutex<T>的API

use std::{ sync::Mutex };

fn main() {
    let m = Mutex::new(5);

    {
        let mut num = m.lock().unwrap();
        *num = 6;
    }

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

多线程共享Mutex<T>

例子报错

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

fn main() {
    let counter = Mutex::new(0);
    let mut handles = vec![];
    
    for _ in 0..10 {
        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());
}

多线程的多重所有权

使用Arc<T>来进行原子引用计数

Arc<T>和Rc<T>类似，它可以用于并发情景

A:atomic,原子的

需要牺牲性能作为代价

Arc<T>和Rc<T>的API相同

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

fn main() {
    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 num = counter.lock().unwrap();

            *num +=1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

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