Rust引用借用测试

rust字面量字符串实现了copy trait；

String是引用类型，可使用clone创建新的对象；

Cell可修改copy trait对象；refcell可修改引用对象；

引用/借用对象有生命周期，超过生命周期自动归还引用/借用；

use std::cell::Cell;
use std::cell::RefCell;
use std::rc::Rc;
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let s1 = String::from("hello02");
	let s2 = format!("s2={}", s1);
	let s3 = s2.clone();
	let s4 = &s2;
    println!("Hello, world! {}", s1);
	println!("hell every one!{}", s2);
	println!("S3={}",s3);
	println!("&s2={}", s4);
	
	let cell_str = Cell::new("cellTest");
	println!("Initial value:{}", cell_str.get());
	cell_str.set("cellTest01");
	println!("Initial value:{}", cell_str.get());
	
	let str_value01 = "hello".to_owned();
	println!("str_value01={}", str_value01);
	test_str_fun(&str_value01);
	println!("str_value01={}", str_value01);
	
	let cell_string = RefCell::new("001".to_owned());
	{
	    cell_change_test02(&cell_string);
	    let text02 = cell_string.borrow();
	    println!("cell_string02={}", *text02);
	}
	cell_change_test03(&cell_string);
	let text03 = cell_string.borrow();
	println!("cell_string03={}", *text03);
	//RC测试 引用计数
	let vec = vec![1,2,3];
	let rc_data = Rc::new(vec);
	let rc_data1 = rc_data.clone();
    rc_data_test1(rc_data1);
	let rc_data2 = rc_data.clone();
	rc_data_test2(rc_data2);
	//RC+RefCell 引用计数+可修改
	let vec = vec![1,2,3];
    let rc_refcell_data = Rc::new(RefCell::new(vec));
	{
	    //独立开辟一个生命周期范围，让vec借用提前结束，方便后续代码继续使用vec对象
	    let mut vec03 = rc_refcell_data.borrow_mut();
	    vec03.push(4);
	}
	println!("{:?}", rc_refcell_data.borrow());
	
	//Arc测试 多线程只读
	let s = Arc::new(String::from("多线程测试"));
	for _ in 0..10 {
	    let si = Arc::clone(&s);
		let _handle = thread::spawn(move ||{
		    println!("{}", si);
		});
	}
	//多线程可变修改
	let counter = Arc::new(Mutex::new(0));
	let mut thread_list = vec![];
	for _ in 0..10{
	    let count_clone = Arc::clone(&counter);
		let handle_i = thread::spawn(move || {
		    let mut num = count_clone.lock().unwrap();
			*num += 1;
		});
		thread_list.push(handle_i);
	}
	
	for handle in thread_list{
	    handle.join().unwrap();
	}
	println!("Final count: {}", *counter.lock().unwrap());
}

fn rc_data_test1(data: Rc<Vec<i32>>){
	println!("data:{:?}", data);
}

fn rc_data_test2(data: Rc<Vec<i32>>){
    println!("data:{:?}", data);
}

fn test_str_fun(str: &String){
    println!("fun {}", str);
}

fn cell_change_test02(cell:&RefCell<String>){
    let mut text = cell.borrow_mut();
    *text = "002".to_owned();
}

fn cell_change_test03(cell:&RefCell<String>){
    let mut text = cell.borrow_mut();
    *text = "003".to_owned();
}