UMBRELLA

未雨绸缪，举重若轻

发表于 分类于 本文字数： 183 阅读时长 ≈ 1 分钟

使用 std::sync::Mutex 可以多线程共享可变数据，Mutex、RwLock 和原子类型，即使声明为 non-mut，这些类型也可以修改：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
use std::borrow::Cow;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

fn main() {
    // 用 Arc 来提供并发环境下的共享所有权（使用引用计数）
    let metrics: Arc<Mutex<HashMap<Cow<'static, str>, usize>>> =
        Arc::new(Mutex::new(HashMap::new()));
    for _ in 0..32 {
        let m = metrics.clone();
        thread::spawn(move || {
            let mut g = m.lock().unwrap();

            // 此时只有拿到 MutexGuard 的线程可以访问 HashMap
            let data = &mut *g;

            // Cow 实现了很多数据结构的 From trait，
            // 所以我们可以用 "hello".into() 生成 Cow
            let value = data.entry("hello".into()).or_insert(0);
            *value += 1;

            // MutexGuard 被 Drop，锁被释放
        });
    }

    thread::sleep(Duration::from_millis(100));
    println!("metrics: {:?}", metrics.lock().unwrap());
}

发表于 分类于 本文字数： 1.4k 阅读时长 ≈ 5 分钟

构造 Double Free

使用 unsafe 特性构造指向同一块内存的两个变量，导致 Double Free：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
use std::{mem, ptr};

fn main() {
    let mut d = String::from("cccc");
    let d_len = d.len();
    
    let mut c = String::with_capacity(d_len);
    unsafe {
        ptr::copy(&d, &mut c, 1);
    };
    println!("{:?}", c.as_ptr());

    println!("{:?}", d.as_ptr());
    d.push_str("c");
    println!("{}", d);
}
阅读全文 »

发表于 分类于 本文字数： 1.8k 阅读时长 ≈ 6 分钟

Rust 中使用 std::result::Result 表示可能出错的操作，成功的时候是 Ok(T)，而出错的时候则是 Err(E)：

1
2
3
4
pub enum Result<T, E> {
    Ok(T),
    Err(E),
}

通常情况下，E 是实现 std::error::Error 的错误类型：

1
2
3
4
5
6
pub trait Error: Debug + Display {
    fn source(&self) -> Option<&(dyn Error + 'static)> { ... }
    fn backtrace(&self) -> Option<&Backtrace> { ... }
    fn description(&self) -> &str { ... }
    fn cause(&self) -> Option<&dyn Error> { ... }
}

我们通常也需要在自己的代码中自定义错误，并且为之手动实现 std::error::Error，这个工作很麻烦，所以就有了 thiserror，自动帮我们生成实现的 std::error::Error 的代码。

而借助于 anyhow::Error，和与之对应的 Result<T, anyhow::Error>，等价于 anyhow::Result<T>，我们可以使用 ? 在可能失败的函数中传播任何实现了 std::error::Error 的错误。

阅读全文 »

发表于 分类于 本文字数： 4.3k 阅读时长 ≈ 14 分钟

一直以来，从 JavaScript，PHP，Python到Golang，然后还有linux系统中，无处不见正则表达式的身影，可是一致困扰在POSIX和PCRE的概念中，分不清这两个是个啥，今天就来翻翻正则表达式的老底，了解了解正则表达式的前世今生。

Regular Expression的Regular一般被译为正则、正规、常规。此处的Regular即是规则的意思，Regular Expression即描述某种规则的表达式之意。

正则表达式（英语：Regular Expression，在代码中常简写为regex、regexp或RE），是计算机科学的一个概念。正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。在很多文本编辑器里，正则表达式通常被用来检索、替换那些匹配某个模式的文本。

许多程序设计语言都支持利用正则表达式进行字符串操作。例如，在Perl中就内建了一个功能强大的正则表达式引擎。正则表达式这个概念最初是由Unix中的工具软件（例如sed和grep）普及开的。正则表达式通常缩写成regex，单数有regexp、regex，复数有regexps、regexes、regexen。

阅读全文 »
0%