在这篇文章中，要分享的例子不仅仅是假设，它们来自于工作中的真实案例，在这些例子中，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;
#[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: 0Rust使用单个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通过在编译时而不是运行时检测错误来确保可靠性，实现高性能，并且具有一定程度的表达性，使其可以编写其他语言无法编写的代码。
