Question

考虑一个阻塞函数：this_thread :: sleep_for（milliseconds（3000））;

我正试图获得以下行为：

Module MyModule.

   Section MyDefs.

      (* Implicit. *)
      Context {T: Type}. 

      Inductive myIndType: Type :=
      | C : T -> myIndType.

   End MyDefs.

End MyModule.

Module AnotherModule.

   Section AnotherSection.

      Context {T: Type}.
      Variable P: Type -> Prop.

      (*              ↓↓         ↓↓ - It's pretty annoying. *)
      Lemma lemma: P (@myIndType T).

   End AnotherSection.

End AnotherModule.

我想触发阻塞功能，如果花费太长时间（超过两秒），它应该超时。

我做了以下事情：

Trigger Blocking Function               

|---------------------------------------------X

我无法让这个工作。对于初学者，我认为s不能从另一个主题开始on_next。

所以我的问题是，这样做的正确反应方式是什么？如何在rxcpp中包含阻塞函数并为其添加超时？

随后，我想得到一个行为如下的RX流：

my_connection = observable<>::create<int>([](subscriber<int> s) {
    auto s2 = observable<>::just(1, observe_on_new_thread()) |
    subscribe<int>([&](auto x) {
        this_thread::sleep_for(milliseconds(3000));
        s.on_next(1);
    });
}) |
timeout(seconds(2), observe_on_new_thread());

Answer 1

好问题！以上情况非常接近。

以下是如何使阻塞操作适应rxcpp的示例。它libcurl polling发出http请求。

以下应该按照您的意图行事。

auto sharedThreads = observe_on_event_loop();

auto my_connection = observable<>::create<int>([](subscriber<int> s) {
        this_thread::sleep_for(milliseconds(3000));
        s.on_next(1);
        s.on_completed();
    }) |
    subscribe_on(observe_on_new_thread()) |
    //start_with(0) | // workaround bug in timeout
    timeout(seconds(2), sharedThreads);
    //skip(1); // workaround bug in timeout

my_connection.as_blocking().subscribe(
    [](int){}, 
    [](exception_ptr ep){cout << "timed out" << endl;}
);

subscribe_on将在专用线程上运行create，因此create可以阻止该线程。
timeout将在不同的线程上运行计时器，可以与其他人共享，并将所有on_next / on_error / on_completed次调用转移到同一个线程
as_blocking将确保subscribe在完成之前不会返回。这仅用于防止main()退出 - 通常用于测试或示例程序。

编辑：为timeout中的错误添加了变通方法。目前，在第一个值到达之前，它不会安排第一个超时。

编辑2：timeout错误已修复，不再需要解决方法。

RXCPP：阻塞功能超时

1 个答案: