请问 RUST 如何控制并发数量?

[DollarKiller]

golang 可以通过 channl 来实现并发数量的限制 如下

	// slice 存储当前需要处理的任务
	task := []string{
		"task1",
		"task2",
		"task3",
	}

	limit := make(chan bool,10) // 定义空间为 10 的 chan 作为限流器

	for i := range task {
		idx := i  // copy
		
		limit<-true  // 每次任务执行  塞入
		go func() {
			defer func() {
				<-limit  // 任务执行完毕 塞出
			}()
			// 处理任务
			fmt.Println("task: ",task[idx])
		}()
	}

rust 有什么好的解决方案呢？ 我是这样写的

use async_std::task;
use std::time::Duration;
use async_std::channel;

#[async_std::main]
async fn main() {
    let mut task_list = Vec::new();
    for i in 0..10000 {
        task_list.push(format!("task: {}",i))
    }

    let (sen,rec) = channel::bounded(10);

    for i in task_list {
        sen.send(1).await;
        let rec = rec.clone();
        task::spawn(async move {
            task::sleep(Duration::from_millis(500)).await;
            println!("Processing {}",i);
            rec.recv().await;
        });
    }

    loop {
        task::sleep(Duration::from_secs(1)).await;
    }
}

如果使用上面方式解决 可能回出现处理 task 时发生异常以至于没有执行 rec.recv().await

go 通过 defer 确定 task 处理完毕时必然回执行 处理令牌 ， rust 怎么解决呢？

使用一个结构体处理 task 并重写它的 Deref trait ？

[kxuanobj]

控制并发量可以用 https://docs.rs/futures/0.3.16/futures/stream/trait.StreamExt.html#method.buffer_unordered

实现 defer 可以这样：

```rust
fn run() {

struct Defer {}
impl Drop for Defer {
fn drop(&mut self) {
println!("defer")
}
}

let f = Defer {};
println!("what ever");

// cancel defer
//std::mem::forget(f);
}
```