在 Elixir 中编写嵌套 for 循环的更好方法

Question

请提出更好的方法（更多的elixir方式）将以下C代码写入elixir。

int some_num = 0;

for(int i = 0; i < 100; i++){
  for(int j = 0; j < 1000; j++){
    for(int k = 0; k < 10000; k++){
      some_num += 1;
    }
  }
}
printf("%d", some_num);

而是否可以通过获得好处elixir并发来实现？

编辑： 一点背景知识，我对长生不老药很新鲜，还在学习。这个问题的主要动机是编写更多惯用的灵丹妙药代码而不是应用并发。

Answer 1

准确实现您所写内容的最简单方法是使用for 宏：

sum =
  for i <- 0..100,
      j <- 0..1_000,
      k <- 0..10_000,
      reduce: 0 do
    acc -> acc + 1
  end

编辑：

:reduce 选项在 Elixir (1.8+) 的新版本中可用。在旧版本中，您可以使用嵌套的Enum.reduce/3：

Enum.reduce(0..100, 0, fn _, acc ->
  acc + Enum.reduce(0..1_000, 0, fn _, acc ->
    acc + Enum.reduce(0..10_000, 0, fn _, acc ->
      acc + 1
    end)
  end)
end)

---

关于问题的第二部分：否，这个循环不会从并发中获得太多收益，如果它会以任何方式改变时间，那么它只会变慢。在这种特殊情况下，它可以写成sum = 100 * 1_000 * 10_000，这样可以更快，因为编译器可以很容易地将其优化为10_000_000（IIRC Erlang 编译器无法将给定循环优化为常量）。

TL;DR 这种明显的循环不能通过并发来改善，一般情况下很难说进程（又名并行化）是否有帮助。记住parallel != concurrent 也很重要，因此在使用N-1 调度程序（默认CPU 数量）的机器上运行N Erlang 的进程不会获得任何加速。

Answer 2

下面是一个工作示例，说明如何为实现 1000000000 次增量操作的玩具问题实现并发 - 如果您对如何完成感到好奇。

下面的代码生成 100 个 Elixir 进程，对应于您的外部循环。内部代码——这两个嵌套循环——（使用Enum.reducesee以更惯用的形式编写）因此同时运行（尽可能由VM）。每个进程的结果被发送到一个专用的接收进程，每当它收到一个新的结果时，它就会从 100 开始倒计时。每个小计都会添加到总计中，然后在收到 100 个小计时打印出来。 测试：将代码保存为文件nested.ex 并使用c nested.ex 在Elixir shell 中编译。使用 Main.main 在该 shell 中运行它。您应该会看到以下输出：

iex(4)> Main.main    
:ok
total = 1000000000

ok 在 total 之前几秒钟出现。您还应该体验高 cpu 多核使用率。

defmodule Main do 
def main(  ) do
    pid = spawn fn -> Receiver.loop( 100,0 ) end
    1..100 |> Enum.each( fn x -> spawn (fn -> Nested.run(pid) end ) end)
  end

end

#################################
defmodule Nested do
 def run(pid) do
    sub_total= 
    Enum.reduce( 1..1000, 0, fn x, acc_n -> acc_n +
      Enum.reduce( 1..10000, 0, fn y, acc_m -> acc_m + 1  end )
    end )
   send pid, sub_total
   Process.exit(self(), :kill )
 end
end

#################################
defmodule Receiver do
 def loop(0, total) do
   IO.puts "total = #{total}"
   Process.exit(self(), :kill )
 end
 #
 def loop(count_down, total ) do # count down to zero collecting totals
    receive do
      sub_total ->
        loop(count_down-1, sub_total + total)
    end
 end
end
#################################

通过明智地将普通spawn转换为Node.spawnsee docs

，可以获得并行性以获得优势而不是纯并发

非正式速度测试 在我的 Win10 电脑上测试报告：

Erlang/OTP 20 [erts-9.0] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:10]
Interactive Elixir (1.8.2) ..

我在这里给出的代码在 16 秒内计算出结果，而 @Hauleth 的结果需要 10 多分钟——因为他似乎只分配了一个核心，而我的核心得到了全部 4 个。