Rust equivalent code for this C++ mutex code - multithreading

Question

The mutex and threads examples on
the internet are not good as I am not able to find how to lock a block of code using a mutex to lock a method.
// 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;
}
What is similar Rust code for this C++ snippet? Locking loops and printing as in Rust example the mutex must be of that type such as
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

I have written this similar code. Is it fine or can it be written in a better way?
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);
}