函数式语言(特别是Erlang)如何/为什么能很好地扩展?

我一直在观察函数式编程语言和function的日益增长的可见性。 我看着他们,没有看到上诉的原因。

然后,最近我在Codemash参加了Kevin Smith的“Erlang基础”演示。

我喜欢这个演示文档,并了解到函数式编程的很多属性使得避免线程/并发问题变得更容易。 我知道状态和可变性的缺乏使得multithreading无法改变相同的数据,但凯文说(如果我理解正确的话)所有的通信都是通过消息发生的,消息是同步处理的(同样避免了并发问题)。

但是我已经读过Erlang用于高度可扩展的应用程序(爱立信首先创build它的全部原因)。 如果每件事都作为一个同步处理的消息来处理,那么如何有效地处理每秒数千个请求呢? 这不就是为什么我们开始走向asynchronous处理 – 所以我们可以利用同时运行多个线程的操作,并实现可扩展性? 看起来这样的架构虽然更安全,但在可扩展性方面却倒退了一步。 我错过了什么?

我了解Erlang的创build者故意避免支持线程以避免并发问题,但我认为multithreading对于实现可伸缩性是必需的。

函数式编程语言如何能够固有地线程安全,但仍然可以扩展?

函数式语言(通常)不依赖于variables的变异。 因此,我们不必保护variables的“共享状态”,因为这个值是固定的。 这反过来又避免了传统语言在整个处理器或机器上实现algorithm所必须经历的大部分环箍跳跃。

Erlang通过在一个消息传递系统中进行烘焙,使其能够在传统的function语言的基础上进一步发展,在一个基于事件的系统中,每个代码只需要担心接收消息和发送消息,而不用担心更大的图像。

这意味着程序员(名义上)不关心消息是在另一个处理器或机器上处理的:简单地发送这个消息足以让它继续下去。 如果它关心回应,它会等待它作为另一个消息

这样做的最终结果是每个片段都独立于其他片段。 没有共享的代码,没有共享的状态和来自消息系统的可以分布在许多硬件(或不是)中的所有交互。

将其与传统系统进行对比:我们必须将互斥体和信号置于“受保护”variables和代码执行的周围。 我们在通过堆栈进行函数调用时有严格的绑定(等待返回发生)。 所有这些都造成了像Erlang这样的无共享系统的瓶颈问题。

编辑:我也应该指出,Erlang是asynchronous的。 你发送你的消息,也许/有一天另一条消息回来。 或不。

斯宾塞关于无序执行的观点也很重要,并得到了很好的回答。

消息队列系统很酷,因为它有效地产生了“正在等待结果”的效果,这是你正在阅读的同步部分。 是什么让这个令人难以置信的令人难以置信的是,这意味着线路不需要顺序执行。 考虑下面的代码:

r = methodWithALotOfDiskProcessing(); x = r + 1; y = methodWithALotOfNetworkProcessing(); w = x * y 

考虑一下,methodWithALotOfDiskProcessing()需要大约2秒才能完成,而methodWithALotOfNetworkProcessing()则需要大约1秒才能完成。 在程序语言中,这段代码需要大约3秒钟的时间才能运行,因为这些代码行将被顺序执行。 我们浪费时间等待一种方法完成,可以与另一种方法同时运行而不需要争夺单个资源。 在function语言中,代码行并不指示处理器何时尝试它们。 一个函数式语言会尝试如下所示:

 Execute line 1 ... wait. Execute line 2 ... wait for r value. Execute line 3 ... wait. Execute line 4 ... wait for x and y value. Line 3 returned ... y value set, message line 4. Line 1 returned ... r value set, message line 2. Line 2 returned ... x value set, message line 4. Line 4 returned ... done. 

多么酷啊? 通过继续使用代码,只需要等待,我们已经将等待时间自动减less到两秒钟! :D所以是的,虽然代码是同步的,但它往往与过程语言有不同的含义。

编辑:

一旦你把这个概念与Godeke的文章结合起来,很容易想象如何简单地利用多个处理器,服务器场,冗余数据存储以及谁知道还有什么。

这很可能是你与顺序混合同步

erlang中的函数体正在被顺序处理。 所以斯宾塞对这个“自动效应”所说的话并不适用于二郎。 你可以用erlang来build模这个行为。

例如,你可以产生一个计算一行中字数的过程。 正如我们有几行,我们为每一行产生一个这样的过程,并接收到答案来计算它的总和。

这样,我们产生了进行“重”计算的进程(利用额外的内核,如果可用的话),然后我们收集结果。

 -module(countwords). -export([count_words_in_lines/1]). count_words_in_lines(Lines) -> % For each line in lines run spawn_summarizer with the process id (pid) % and a line to work on as arguments. % This is a list comprehension and spawn_summarizer will return the pid % of the process that was created. So the variable Pids will hold a list % of process ids. Pids = [spawn_summarizer(self(), Line) || Line <- Lines], % For each pid receive the answer. This will happen in the same order in % which the processes were created, because we saved [pid1, pid2, ...] in % the variable Pids and now we consume this list. Results = [receive_result(Pid) || Pid <- Pids], % Sum up the results. WordCount = lists:sum(Results), io:format("We've got ~p words, Sir!~n", [WordCount]). spawn_summarizer(S, Line) -> % Create a anonymous function and save it in the variable F. F = fun() -> % Split line into words. ListOfWords = string:tokens(Line, " "), Length = length(ListOfWords), io:format("process ~p calculated ~p words~n", [self(), Length]), % Send a tuple containing our pid and Length to S. S ! {self(), Length} end, % There is no return in erlang, instead the last value in a function is % returned implicitly. % Spawn the anonymous function and return the pid of the new process. spawn(F). % The Variable Pid gets bound in the function head. % In erlang, you can only assign to a variable once. receive_result(Pid) -> receive % Pattern-matching: the block behind "->" will execute only if we receive % a tuple that matches the one below. The variable Pid is already bound, % so we are waiting here for the answer of a specific process. % N is unbound so we accept any value. {Pid, N} -> io:format("Received \"~p\" from process ~p~n", [N, Pid]), N end. 

这就是我们在shell中运行时的样子:

 Eshell V5.6.5 (abort with ^G) 1> Lines = ["This is a string of text", "and this is another", "and yet another", "it's getting boring now"]. ["This is a string of text","and this is another", "and yet another","it's getting boring now"] 2> c(countwords). {ok,countwords} 3> countwords:count_words_in_lines(Lines). process <0.39.0> calculated 6 words process <0.40.0> calculated 4 words process <0.41.0> calculated 3 words process <0.42.0> calculated 4 words Received "6" from process <0.39.0> Received "4" from process <0.40.0> Received "3" from process <0.41.0> Received "4" from process <0.42.0> We've got 17 words, Sir! ok 4> 

使Erlang扩展的关键在于并发性。

操作系统通过两种机制来提供并发性:

  • 操作系统进程
  • 操作系统线程

进程不共享状态 – 一个进程不能通过devise使另一个进程崩溃。

线程共享状态 – 一个线程可能会因devise而崩溃 – 这是您的问题。

使用Erlang–虚拟机使用一个操作系统进程,VM为Erlang程序提供并发性,而不是通过使用操作系统线程,而是通过提供Erlang进程 – 也就是Erlang实现自己的时间logging器。

这些Erlang进程通过发送消息(由Erlang VM而不是操作系统来处理)相互通信。 Erlang进程使用具有三部分地址<<N3.N2.N1>>的进程ID(PID)相互地址:

  • 不处理N1
  • VM N2开启
  • 物理机器N3

同一台虚拟机上的两个进程,同一台机器上的不同虚拟机或两台机器以相同的方式进行通信 – 因此,您的扩展与您部署应用程序的物理机数量(第一次近似)无关。

Erlang只是一个微不足道的线程安全 – 它没有线程。 (SMP /多核VM使用的语言是每个核心使用一个操作系统线程)。

您可能会误解Erlang的工作原理。 Erlang运行时最大限度地减less了CPU上的上下文切换,但是如果有多个可用的CPU,则全部用于处理消息。 在其他语言中,您没有“线程”,但可以同时处理大量的消息。

参考透明度:请参阅http://en.wikipedia.org/wiki/Referential_transparency_ (computer_science)

Erlang消息是纯粹的asynchronous的,如果你想同步回复你的消息,你需要明确的代码。 可能会说的是,进程消息框中的消息是按顺序处理的。 任何发送到进程的消息都会放在进程消息框中,进程从该进程中select一个消息来处理它,然后按照它认为合适的顺序继续进行下一个消息。 这是一个非常顺序的行为,接收块完全是这样做的。

看起来你已经混淆了同步和顺序克里斯提到。

在一个纯粹的函数式语言中,评估顺序并不重要 – 在一个函数应用程序fn(arg1,… argn)中,n个参数可以并行计算。 这保证了高水平的(自动)并行性。

Erlang使用一个进程modell,一个进程可以运行在同一个虚拟机上,或者在一个不同的处理器上运行 – 这是无法告诉的。 这是唯一可能的,因为消息在进程之间复制,没有共享(可变)的状态。 多处理器并列比multithreading要远得多,因为线程依赖于共享内存,在8核CPU上只能有8个线程并行运行,而多处理可以扩展到数千个并行进程。