在这篇文章中，要分享的例子不仅仅是假设，它们来自于工作中的真实案例，在这些例子中，Go的局限性无法实现所需的解决方案。声明：这里的区别并不在于Rust代码比Go代码更正确或更快。

1，读取线程的ID
记录当前线程的ID，或者在Go的情况下，记录协程ID，是非常有用的。它明确了哪个线程正在做什么。如果没有这些信息，每个线程的活动就会交织在一个日志文件中，因此很难跟踪单个执行流。

在Rust中，获取线程id就像这样简单：

let id = thread::current().id();

然而，Go并不公开协程id。Go故意不公开协程id，以阻止开发人员对线程本地存储进行编程。对于想要理解日志的开发人员必须求助于其他方法来检索该信息。

2，单个Select语句中的Case优先级排序
Go在select-case语句(等待多个通道操作)中随机选择所有就绪中的一个。如果准备好了多个case，并且希望在单个select语句中优先执行一个case，则不行。在下面的代码中，nReady1在统计上等于nReady2。

func main() {
    ready1 := make(chan struct{})
    close(ready1)
    ready2 := make(chan struct{})
    close(ready2)

    nReady1 := 0
    nReady2 := 0
    N := 10_000
    for i := 0; i < N; i++ {
        select {
        case <-ready1:
           nReady1++
        case <-ready2:
           nReady2++
        }
    }
    fmt.Println("nReady1:", nReady1)
    fmt.Println("nReady2:", nReady2)
}

执行结果：

nReady1: 4943
nReady2: 5057

必须使用嵌套的select语句(带有默认值)来实现优先级。

select {
    case <-ready1:
       nReady1++
    default:
       select {
          case <-ready1:
             nReady1++
          case <-ready2:
             nReady2++
       }
}

然而，Rust的异步运行时Tokio允许在单个select语句中使用biased关键字设置优先级顺序。在下面的例子中，按照它们在代码中出现的顺序排列优先级。

use tokio::sync::mpsc;
use tokio::select;
# 堆代码 duidaima.com
#[tokio::main]
async fn main() {
    let (tx1, mut rx1) = mpsc::channel::<()>(1);
    drop(tx1);
    let (tx2, mut rx2) = mpsc::channel::<()>(1);
    drop(tx2);

    let mut n_ready1 = 0;
    let mut n_ready2 = 0;
    let n = 10_000;
    for _ in 0..n {
        select! {
            biased; // 按出现的顺序优先处理已准备好的case
            _ = rx1.recv() => {
                n_ready1 += 1;
            },
            _ = rx2.recv() => {
                n_ready2 += 1;
            },
        }
    }

    println!("n_ready1: {}", n_ready1);
    println!("n_ready2: {}", n_ready2);
}

执行结果：

n_ready1: 10000
n_ready2: 0

Rust使用单个select语句实现了对case的优先级排序。

3，具有指针和值接收器的泛型类型
在Go中，你想为类型参数S定义一个类型约束，它实现了两个方法：

type S struct{}

func (s S) M()  {}
func (s *S) P() {}

不幸的是，不可能用单个类型约束指定这两个方法。必须使用两个单独的类型参数，每个类型参数都有自己的约束，然后将它们链接到函数f中。首先，定义T受Mer接口类型的约束。然后，将PT定义为受Per[T]接口类型约束，并引用第一个T。这看起来很复杂，并不直观。

type Per[T any] interface {
    P()
    *T // 非接口类型约束元素
}

type Mer interface {
    M()
}

func f[T Mer, PT Per[T]](t T) {
    PT(&t).P()
    t.M()
}

在Rust中，解决方案很简单。定义一个单独的trait：MyTrait，然后将它用作f中的一个trait绑定。

trait MyTrait {
    fn M(&self);
    fn P(&mut self);
}

struct S;

impl MyTrait for S {
     fn M(&self) {}
    fn P(&mut self) {}
}

fn f<T: MyTrait>(t: &mut T) {
    t.M();
    t.P();
}

总结
Rust通过在编译时而不是运行时检测错误来确保可靠性，实现高性能，并且具有一定程度的表达性，使其可以编写其他语言无法编写的代码。