thread::spawn(move ||println!("123"));
thread::sleep(std::Duration::from_secs(1));
Copy

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

fn main() {
    // 创建一个消息通道, 返回一个元组：(发送者，接收者)
    let (tx, rx) = mpsc::channel();

    // 创建线程，并发送消息
    thread::spawn(move || {
        // 发送一个数字1, send方法返回Result<T,E>，通过unwrap进行快速错误处理
        tx.send(1).unwrap();

        // 下面代码将报错，因为编译器自动推导出通道传递的值是i32类型，那么Option<i32>类型将产生不匹配错误
        // tx.send(Some(1)).unwrap()
    });

    // 在主线程中接收子线程发送的消息并输出
    println!("receive {}", rx.recv().unwrap());
}
Copy

// 常用的异步channel
let (tx, rx) = mpsc::channel();
// 同步channel
let (tx, rx)= mpsc::sync_channel(0);
Copy

for x in recv {
  println!("Got: {}", x);
}
Copy

use std::sync::Mutex;

let counter = Arc::new(Mutex::new(0));
for _ in 0..10 {
  let counter = Arc::clone(&counter);
  let handle = thread::spawn(move || {
    let mut num = counter.lock().unwrap();
    *num += 1;
});
Copy

use std::sync::RwLock;

fn main() {
    let lock = RwLock::new(5);

    // 同一时间允许多个读
    {
        let r1 = lock.read().unwrap();
        let r2 = lock.read().unwrap();
        assert_eq!(*r1, 5);
        assert_eq!(*r2, 5);
    } // 读锁在此处被drop

    // 同一时间只允许一个写
    {
        let mut w = lock.write().unwrap();
        *w += 1;
        assert_eq!(*w, 6);

        // 以下代码会panic，因为读和写不允许同时存在
        // 写锁w直到该语句块结束才被释放，因此下面的读锁依然处于`w`的作用域中
        // let r1 = lock.read();
        // println!("{:?}",r1);
    }// 写锁在此处被drop
}
Copy

const A: i32 = 1;
static mut REQUEST_RECV: i32 = 1;
fn main() {
   unsafe {
        REQUEST_RECV += 1;
        assert_eq!(REQUEST_RECV, 1);
   }
}
Copy

use std::sync::atomic::{AtomicUsize, Ordering};
static REQUEST_RECV: AtomicUsize  = AtomicUsize::new(0);
fn main() {
    for _ in 0..100 {
        REQUEST_RECV.fetch_add(1, Ordering::Relaxed);
    }

    println!("当前用户请求数{:?}",REQUEST_RECV);
}
Copy

[dependencies]
futures = "0.3"
Copy

use futures::executor::block_on;

async fn hello_world() {
    println!("hello, world!");
}

fn main() {
    let future = hello_world(); // 返回一个Future, 因此不会打印任何输出
    block_on(future); // 执行`Future`并等待其运行完成，此时"hello, world!"会被打印输出
}
Copy

use futures::executor::block_on;

async fn hello_world() -> u32 {
    println!("hello, world!");
    1
}
async fn call_another() {
    let one = hello_world().await;
    println!("{}", one);
}
fn main() {
    let future = call_another();
    block_on(future);
}
Copy

fn main() {
    let i = String::from("world");
    let f = async {
      println!("hello {}", i);
    };
    block_on(f);
    println!("hello {}", i);
}
Copy

fn main() {
    let i = String::from("world");
    let f = async move{
      println!("hello {}", i);
    };
    block_on(f);
    println!("hello {}", i);// i已经move走了，此时报错
}
Copy

async fn foo() -> Result<u8, String> {
    Ok(1)
}
async fn bar() -> Result<u8, String> {
    Ok(1)
}
pub fn main() {
    let fut = async {
        foo().await?;
        bar().await?;
        Ok(())
    };
}
Copy

let fut = async {
    foo().await?;
    bar().await?;
    Ok::<(), String>(()) // 在这一行进行显式的类型注释
};
Copy

[dependencies]
reqwest = { version = "0.11.11", features = ["json", "cookies"] }
tokio = { version = "1", features = ["full"] }
Copy

#[tokio::main]
async fn main() {
   let data = request_data().await.unwrap();
   println!("{:?}", data);
}
Copy

use std::collections::HashMap;
use std::error::Error;

async fn request_data() -> Result<String, Box<dyn Error>> {
    // 准备请求参数, url
    let mut map = HashMap::new();
    map.insert("a", "1");

    const url = "https://www.baidu.com";

    let client = reqwest::Client::builder().build().unwrap();

    let res = client.post(url).json(&map).send().await?
        .text().await?;
    Ok(res)
  }
Copy

const URL: &str = "https://www.baidu.com";
static mut CLIENT: Option<reqwest::Client> = None;

async fn request_data() -> Result<String, Box<dyn Error>> {
    let client;
    unsafe {
        client = CLIENT.get_or_insert(reqwest::Client::builder().build().unwrap());
    }
//....
Copy

use lazy_static::lazy_static;

lazy_static! {
    static ref client: reqwest::Client = reqwest::Client::builder().build().unwrap();
}
Copy