此 C++ 互斥代码的 Rust 等效代码

Question

互斥量和线程示例 互联网不好，因为我无法找到如何使用互斥锁锁定代码块来锁定方法。

// mutex example
#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex

std::mutex mtx;           // mutex for critical section

void print_block (int n, char c) {
  // critical section (exclusive access to std::cout signaled by locking mtx):
  mtx.lock();
  for (int i=0; i<n; ++i) { std::cout << c; }
  std::cout << '\n';
  mtx.unlock();
}

int main ()
{
  std::thread th1 (print_block,50,'*');
  std::thread th2 (print_block,50,'$');

  th1.join();
  th2.join();

  return 0;
}

这个 C++ sn-p 的类似 Rust 代码是什么？在 Rust 示例中锁定循环和打印，互斥锁必须是那种类型，例如

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

fn main() {
    let data = Arc::new(Mutex::new(vec![1u32, 2, 3]));

    for i in 0..3 {
        let data = data.clone();

        thread::spawn(move || {
            let mut data = data.lock().unwrap();
            data[i] += 1;
        });
    }
    thread::sleep_ms(50);
}

Answer 1

我写过类似的代码。写得好还是可以写得更好？

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

fn main() {
    let mtx = Arc::new(Mutex::new(""));

    let mtx1 = mtx.clone();

    let mtx2 = mtx.clone();

    let n = 50;

    let th1 = thread::spawn(move || {
        mtx1.lock().unwrap();

        printData(n, "*".to_string());
    });

    let th2 = thread::spawn(move || {
        mtx2.lock().unwrap();

        printData(n, "$".to_string());
    });

    th1.join();
    th2.join();
}

fn printData(n: u32, c: String) {
    let mut str_val: String = "".to_string();

    for i in 0..n {
        str_val.push_str(&c);
    }

    println!("{}", str_val);
}