Question

以下场景：GenStage生产者处理Twitter流（使用Stream API和ExTwitter）并向GenStage消费者提供一组推文（最大消费者要求的需求）。然后消费者只是打印它们。

以下问题：我正在寻找具体的推文，所以总有新的推文没有。如果GenStage生产者返回一个空的事件列表，消费者将停止询问。有关详情，请参阅this issue and José Valims reply。

我不确定如何解决这个问题。任何帮助是极大的赞赏。这就是我到目前为止所做的：

defmodule MyApp.TwitterProducer do
  use GenStage
  alias MyApp.TwitterStream

  def start_link(:ok) do
    GenStage.start_link(__MODULE__, :ok)
  end

  def init(:ok) do
    # This creates a regular Elixir Stream
    # I use this as the state so that not every
    # time the consumer asks for new data
    # a new stream is initiated
    stream = TwitterStream.get_stream
    {:producer, stream}
  end

  def handle_demand(demand, stream) do
    # Take tweets from the stream and 
    # turn them into a list. Then return 
    # them to the consumer
    chunk = Stream.take(stream, demand)
    events = Enum.to_list(chunk)
    {:noreply, events, stream}
  end


  def handle_info(_msg, state) do
    # I as getting an "wrong message" error 
    # before I implemented this function myself
    # It does nothing special to my case
    {:noreply, [], state}
  end

end

defmodule MyApp.TwitterConsumer do
  use GenStage

  def start_link() do
    GenStage.start_link(__MODULE__, :ok)
  end

  def init(:ok) do
    {:consumer, :the_state_does_not_matter}
  end

  def handle_events(events, _from, state) do

    Process.sleep(3000)
    IO.inspect(events)

    # We are a consumer, so we would never emit items.
    {:noreply, [], state}
  end

end

# Let's fire this thing up
{:ok, p} = GenStage.start_link(MyApp.TwitterProducer, :ok, name: MyApp.TwitterProducer)
{:ok, c} = GenStage.start_link(MyApp.TwitterConsumer, :ok, name: MyApp.TwitterConsumer)
GenStage.sync_subscribe(c, to: p, max_demand: 3)

会发生什么：这会运行一段时间，然后停止。据我所知，生产者返回一个空事件列表。

编辑：有趣的是：如果我将需求设置为1，它就会继续运行。但它比直接查询Twitter Stream API要慢得多。这意味着我收到的推文少了十倍。我的理论是，它是由于重复的Stream.take调用，而不是仅为整个流调用Enum.to_list。但我觉得它仍然很混乱。我缺少什么想法？

Answer 1

GenStage.handle_demand/2的文档中有一个重要的（但很遗憾没有粗体表示）句子：

制作人必须存储需求或返回所请求的事件。

也就是说，代替Stream.take上的阻塞，可能会明确地意识到任务可能阻塞并处理这种情况，在这种情况下使用Task.await/2以合理的超时收集需求（也许Task.yield/2可以在更复杂的检查中使用，但在这里似乎是一种矫枉过正。）

来自文档：

如果您不希望任务失败，那么您必须以与实现它相同的方式更改heavy_fun/0代码，如果您没有异步调用。例如，要么返回{:ok, val} | :error结果，要么在更极端的情况下，使用try/rescue 。

但是文档缺少示例。 OTOH，在这里返回空列表并忘记收集需求可能会更容易：

def handle_demand(demand, stream) do
  try do
    task = Task.async(fn ->
      stream
      |> Stream.take(demand)
      |> Enum.to_list()
    end)
    Task.await(task, 1000) # one sec
  catch
    :exit, {:timeout, {Task, :await, [_, 1000]}} ->
      {:noreply, [], stream}
  else
    events when is_list(events) ->
      {:noreply, events, stream}
  end
end

GenStage：如何处理生产者无法提供事件的情况？

1 个答案: