具有自有值的 Rust 块方法？

Question

我尝试同时对多个字符串块执行并行操作，但我发现借用检查器存在问题：

（对于上下文，identifiers 是来自 CSV 文件的 Vec<String>，client 是 reqwest，target 是一次写入的 Arc<String>阅读很多）

use futures::{stream, StreamExt};
use std::sync::Arc;

async fn nop(
    person_ids: &[String],
    target: &str,
    url: &str,
) -> String {
    let noop = format!("{} {}", target, url);
    let noop2 = person_ids.iter().for_each(|f| {f.as_str();});
    "Some text".into()
}

#[tokio::main]
async fn main() {
    let target = Arc::new(String::from("sometext"));
    let url = "http://example.com";
    let identifiers = vec!["foo".into(), "bar".into(), "baz".into(), "qux".into(), "quux".into(), "quuz".into(), "corge".into(), "grault".into(), "garply".into(), "waldo".into(), "fred".into(), "plugh".into(), "xyzzy".into()];

    let id_sets: Vec<&[String]> = identifiers.chunks(2).collect();

    let responses = stream::iter(id_sets)
        .map(|person_ids| {
            let target = target.clone();
            tokio::spawn( async move {
                let resptext = nop(person_ids, target.as_str(), url).await;
            })
        })
        .buffer_unordered(2);

    responses
        .for_each(|b| async { })
        .await;
}

游乐场：https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=e41c635e99e422fec8fc8a581c28c35e

给定块产生 Vec<&[String]>，编译器抱怨 identifiers 没有足够长的时间，因为它可能在引用切片时超出范围。实际上这不会发生，因为有等待。有没有办法告诉编译器这是安全的，或者是否有另一种方法可以将块作为每个线程的一组拥有的字符串获取？

有一个使用 into_owned() 作为解决方案的类似问题，但是当我尝试这样做时，rustc 抱怨 request_user 函数在编译时不知道切片大小.

编辑：还有一些其他问题：

是否有更直接的方法在每个线程中使用 target 而无需 Arc？从创建的那一刻起，就永远不需要修改，直接读取即可。如果没有，有没有办法将它从不需要 .as_str() 方法的 Arc 中拉出来？
如何处理 tokio::spawn() 块中的多种错误类型？在实际使用中，我将在其中接收 quick_xml::Error 和 reqwest::Error。它在没有 tokio spawn 并发的情况下工作正常。

Answer 1

您的问题是标识符是对切片的引用的 Vector。一旦你离开了你的函数的范围，它们就不一定会存在了（这是里面的 async move 会做的）。

您解决当前问题的方法是将 Vec<&[String]> 转换为 Vec<Vec<String>> 类型。

实现该目标的方法是：

    let id_sets: Vec<Vec<String>> = identifiers
        .chunks(2)
        .map(|x: &[String]| x.to_vec())
        .collect();

Answer 2

Is there a way to tell the compiler that this is safe, or is there another way of getting chunks as a set of owned Strings for each thread?

您可以将 Vec<T> 分块到 Vec<Vec<T>> 而无需克隆 ，方法是使用 itertools 包装箱：

use itertools::Itertools;

fn main() {
    let items = vec![
        String::from("foo"),
        String::from("bar"),
        String::from("baz"),
    ];
    
    let chunked_items: Vec<Vec<String>> = items
        .into_iter()
        .chunks(2)
        .into_iter()
        .map(|chunk| chunk.collect())
        .collect();
        
    for chunk in chunked_items {
        println!("{:?}", chunk);
    }
}

["foo", "bar"]
["baz"]

这是基于回答。

具有自有值的 Rust 块方法？

Rust chunks method with owned values?

rust

chunks

tokio