rust:线程 - 技术栈

1线程

类似于c++，创建线程可以直接传入已经定义的函数，也可以传入闭包，rust中的闭包和c++中的lambda表达式类似。c++中的lambda表达是可以捕获数据，引用捕获和值捕获都可以；rust中的闭包，需要通过move。

本例子中，handle2如果只用到msg的话，不需要move捕获，为什么？

rust 复制代码

use std::thread;
use std::time::Duration;

fn hello_thread() {
  println!("hello thread");
}

fn print_message(msg: String) {
  println!("msg: {}", msg);
}

fn main() {
  let handle1 = thread::spawn(hello_thread);

  let handle2 = thread::spawn(|| {
      for i in 1..10 {
        println!("hi number {} from this spawned thread2!", i);
        thread::sleep(Duration::from_millis(1));
      }
    }
  );

  let msg = String::from("hello rust thread");
  let v = vec![1, 2, 3];
  let handle3 = thread::spawn(move || {
      print_message(msg);
      println!("Here's a vector: {:?}", v);
    }
  );

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

  handle1.join().unwrap();
  handle2.join().unwrap();
  handle3.join().unwrap();
}

2通道channel

类似于go语言，go语言中也有channel。

rust 复制代码

use std::thread;
use std::sync::mpsc;
use std::time::Duration;

fn main() {
  let (tx, rx) = mpsc::channel();
  let tx1 = mpsc::Sender::clone(&tx);

  let handle1 = thread::spawn(move || {
    let vals = vec![String::from("hello"), String::from("thread1")];
    for val in vals {
      tx.send(val).unwrap();
      thread::sleep(Duration::from_secs(1));
    }
  });

  let handle2 = thread::spawn(move || {
    let vals = vec![String::from("hello"), String::from("thread2")];
    for val in vals {
      tx1.send(val).unwrap();
      thread::sleep(Duration::from_secs(1));
    }
  });

  for recv in rx {
    println!("recv {}", recv);
  }

  handle1.join().unwrap();
  handle2.join().unwrap();
}

3多线程加锁

c++中的锁和数据时分离的，而rust中的锁和数据时集成到一块的。

rust 复制代码

use std::sync::{Mutex, Arc};
use std::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());
}