Question

我正在尝试为庞大的数据结构提问和回答服务器。用户将JSON问题发送到服务器，服务器将使用庞大的数据结构来回答。

我尝试通过为hyper::server::Service结构实现Oracle特征来实现此目的。

我有这样的事情：

use self::hyper::server::{Http, Service, Request, Response};
// ...other imports

struct Oracle { /* Tons of stuff */}

impl<'a> Service for &'a Oracle {
    type Request = Request;
    type Response = Response;
    type Error = hyper::Error;
    type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;

    fn call(&self, req: Request) -> Self::Future {
         match (req.method(), req.path()) {
            // could be lots of question types
            (&hyper::Method::Post, "/query") => {
                Box::new(req.body().concat2().map(|b| {
                    let query: Query = deserialize_req(&b.as_ref());
                    let ans = get_answer(&self, &query);
                    Response::new()
                        .with_header(ContentLength(ans.len() as u64))
                        .with_body(ans)
                }))
            },
            _ => {
                let response = Response::new()
                    .with_status(hyper::StatusCode::NotFound);
                Box::new(futures::future::ok(response))
            },
        }
    }
}

当我尝试将cannot infer an appropriate lifetime due to conflicting requirements放在未来时会导致生命周期问题（&self）。

我倾向于认为这完全是解决这个问题的错误方法，但我很难找到最佳方法。

Answer 1

请注意，这些期货将是计算密集型的，在CPU pool上运行它们并避免在异步单线程Tokio Core堆栈上运行它们是有意义的。

&self中的call是对呼叫网站管理的内存的引用。调用站点可能在调用之后立即释放该内存，或者在其他时间我们无法控制，因此在闭包中保存引用（“关闭引用”）以供稍后使用是错误的。

为了以更好地共享的方式管理内存，您经常使用引用计数指针。然后Oracle内存将由引用计数指针而不是调用站点拥有，允许您使用闭包和线程自由共享Oracle。

如果你想并行处理这些未来，你需要一个线程安全的引用计数指针，例如Arc。

要使用Arc，您可以将call转换为免费功能：

fn call(oracle: Arc<Oracle>, req: Request) -> OracleFuture

或使用特征在指针上实现call：

struct Oracle { /* Tons of stuff */}

type OraclePt = Arc<Oracle>;

trait OracleIf {
  fn call(&self, req: Request) -> Self::Future
}

impl OracleIf for OraclePt {
  fn call(&self, req: Request) -> Self::Future {
    ...
            let oracle: OraclePt = self.clone();
            Box::new(req.body().concat2().map(move |b| {  // Close over `oracle`.
                let query: Query = deserialize_req(&b.as_ref());
                let ans = get_answer(&*oracle, &query);
                Response::new()
                    .with_header(ContentLength(ans.len() as u64))
                    .with_body(ans)
            }))
  }
}

我们在这里关闭了引用计数指针的副本。

如果你不喜欢使用引用计数指针的想法，那么另一个选择是使用“作用域线程池”，一个线程池，保证子线程在父线程之前被终止，可以安全地与子线程共享Oracle引用如果不将计算包装在Future中，可能更容易做到后者。

在对结构的引用上实现hyper :: Service

1 个答案: