RUST 高性能几种使用方式（一）

1. 线程

unwrap(); 为不安全处理，在这里只是为了简单展示使用，或使用?号，在返回时对错误进行处理。

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        // 线程要执行的代码
    });

    handle.join().unwrap();  // 等待线程结束
}

2.异步编程

Rust的异步编程模型允许实现无阻塞I/O操作.  使用 async/await语法

use tokio::net::TcpListener;
use tokio::prelude::*;

#[tokio::main]
async fn main() -> io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:12345").await?;

    loop {
        let (socket, _) = listener.accept().await?;
        tokio::spawn(async move {
            // 处理socket
        });
    }
}

3.消息传递

一个接收者与N个发送者解决了项目中大部分使用场景。

对于通知与消息先后不要求的情况，很实用。

use std::sync::mpsc;
use std::thread;

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

    thread::spawn(move || {
        tx.send("Hello, world!").unwrap();
    });

    println!("Received: {}", rx.recv().unwrap());
}

4.原子操作

无锁处理方式，其中包括AtomicBool、AtomicIsize等多种原子操作。具体可查看文档

use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread;

fn main() {
    let count = Arc::new(AtomicUsize::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let count = Arc::clone(&count);
        let handle = thread::spawn(move || {
            for _ in 0..1000 {
                count.fetch_add(10000, Ordering::Relaxed);
            }
        });
        handles.push(handle);
    }

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

    println!("Result: {}", count.load(Ordering::Relaxed));
}

5.共享状态并发

RwLock、Mutex、Arc一起使用，保证线程中共享与使用数据。

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

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..100 {
        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());
}