blocks|key|113616|text|我很高兴地告诉你，你是对的，基于CLR的F#根本不会受到这种限制，相反，它受益于多线程的特定功能，包括async+workflows、the+mailboxprocessor和即将推出的精彩的(.NET+4.0)任务并行库。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|113617|entityMap|0|LINK|mutability|MUTABLE|url|http://lorgonblog.spaces.live.com/blog/cns!701679AD17B6D310!194.entry|1|http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/fsharp.core/microsoft.fsharp.control.type_mailboxprocessor-1.html^0|1F|F|0|1V|K|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

I'm happy to tell you that you're right and that F#, being based on the CLR, doesn't suffer from that limitation at all, and instead benefits from multithreading specific features including <a href="http://lorgonblog.spaces.live.com/blog/cns!701679AD17B6D310!194.entry" rel="nofollow noreferrer">async workflows</a>, <a href="http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/fsharp.core/microsoft.fsharp.control.type_mailboxprocessor-1.html" rel="nofollow noreferrer">the mailboxprocessor</a>, and the wonderful upcoming (.NET 4.0) Task Parallel Library.

blocks|key|4317225|text|有很多很好的实现。目前，Haskell人员似乎获得了最好的结果(参见ICFP+2009+paper+by+Simon+Marlow+and+others和Haskell+Symposium+2009+paper+by+Donnie+Jones+and+others)。Erlang紧随其后，特别是如果你想进行分布式的话。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4317226|在6到12个月内，答案可能会发生变化:-)|4317227|entityMap|0|LINK|mutability|MUTABLE|url|http://www.haskell.org/~simonmar/papers/multicore-ghc.pdf|1|http://www.haskell.org/~simonmar/papers/threadscope.pdf^0|Y|16|0|25|1J|1|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

There are a number of good implementations out there. At the moment, the Haskell people seem to be getting the best results (see <a href="http://www.haskell.org/~simonmar/papers/multicore-ghc.pdf" rel="noreferrer">ICFP 2009 paper by Simon Marlow and others</a> as well as <a href="http://www.haskell.org/~simonmar/papers/threadscope.pdf" rel="noreferrer">Haskell Symposium 2009 paper by Donnie Jones and others</a>). Erlang is quite close behind, especially if you want to go distributed.

In six to twelve months the answers may have changed :-)

blocks|key|4317057|text|通过Data+Parallel+Haskell实现的Haskell+supports+parallel+threads|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4317058|entityMap|0|LINK|mutability|MUTABLE|url|http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell|1|http://www.haskell.org/ghc/docs/6.4/html/users_guide/concurrent-and-parallel.html^0|2|L|0|Y|P|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

Haskell <a href="http://www.haskell.org/ghc/docs/6.4/html/users_guide/concurrent-and-parallel.html" rel="nofollow noreferrer">supports parallel threads</a> via <a href="http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell" rel="nofollow noreferrer">Data Parallel Haskell</a>

blocks|key|1100341|text|Scala和Clojure都运行在JVM上，这允许真正的并发，没有任何单点争用瓶颈。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1100342|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Scala and Clojure are both running on the JVM, which allows real concurrency without any single point of contention bottlenecks.

blocks|key|113667|text|Erlang实现自己的进程和进程调度，并允许数千、数万甚至数百万个Erlang进程(在单个操作系统进程内)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|113668|在SMP和多核机器中，Erlang虚拟机将为其进程调度程序和进程队列分配尽可能多的OS线程和OS进程，以最大限度地利用硬件体系结构中的底层并发操作。|113669|当然，向应用程序公开的并发范例保持不变。|113670|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Erlang implements its own processes and process schedule and allows thousands, tens of thousands and even millions of Erlang processes (inside a single Operating System process).

In SMP and multi-core machines the Erlang Virtual Machine will allocate as many OS threads and OS processes to its process scheduler and process queue to maximise its use of underlying concurrent operations in the hardware architecture.

The concurrency paradigm exposed to the applications remains the same, of course.

blocks|key|4317157|text|除了Haskell之外，您还可以在Erlang+(面向并发的编程)中并发运行进程，也可以使用.NET+Parallel+Extensions和Asynchronous+Workflows在F#中执行此操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4317158|entityMap|0|LINK|mutability|MUTABLE|url|http://weblogs.asp.net/podwysocki/archive/2009/02/23/adding-parallel-extensions-to-f.aspx|1|http://blogs.msdn.com/dsyme/archive/2007/10/11/introducing-f-asynchronous-workflows.aspx^0|1A|O|0|1Z|M|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

In addition to Haskell, you can run processes concurrently in Erlang (Concurrency-Oriented Programming) and you can also do so in F# using <a href="http://weblogs.asp.net/podwysocki/archive/2009/02/23/adding-parallel-extensions-to-f.aspx" rel="nofollow noreferrer">.NET Parallel Extensions</a> and <a href="http://blogs.msdn.com/dsyme/archive/2007/10/11/introducing-f-asynchronous-workflows.aspx" rel="nofollow noreferrer">Asynchronous Workflows</a>.

blocks|key|1415002|text|只需补充一些内容，以确认猜测列表的更多部分：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1415003|1415004|Poly/ML从版本5.2+(从2006开始)开始支持本机线程(POSIX线程或Windows线程)。当前的Poly/ML+5.5+(2012年夏季)已经改进了对并行内存管理的支持:一些GC阶段使用多线程，有特殊的在线共享不可变值的支持，以减少巨大的内存占用，applications.|unordered-list-item|1415005|Isabelle/ML为Poly/ML线程提供了一个附加的未来库。伊莎贝尔是一个交互式定理证明者，但它与基于Poly/ML的增广版本SML集成在一起。|1415006|1415007|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|L|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|M|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|N|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|J|$]]

Just some additions to confirm further parts of the speculative list:

<ul>
<li>Poly/ML supports native threads (POSIX threads or Windows threads) since version 5.2 (from 2006). Current Poly/ML 5.5 (summer 2012) has improved support for parallel memory management: some of the GC phases use multiple threads, there is special support for online sharing of immutable values to reduce memory footprint of huge applications.</li>
<li>Isabelle/ML provides an add-on future library for Poly/ML threads. Isabelle is an interactive theorem prover, but it is integrated with an augmented version SML based on Poly/ML.</li>
</ul>

blocks|key|1414973|text|python不是一种特别的函数式语言，对于GIL，它也不是很并行，但与multiprocessing模块(从2.6开始就是标准的)相结合，您可以同时获得两者，但它不如纯函数式语言那么优雅。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1414974|Brief+example:|1414975|from+multiprocessing+import+Pool

def+f(x):
++++return+x*x

if+__name__+==+'__main__':
++++pool+=+Pool(processes=4)++++++++++++++#+start+4+worker+processes
++++result+=+pool.apply_async(f,+[10])+++++#+evaluate+"f(10)"+asynchronously
++++print+result.get(timeout=1)+++++++++++#+prints+"100"+unless+your+computer+is+*very*+slow
++++print+pool.map(f,+range(10))++++++++++#+prints+"[0,+1,+4,...,+81]"|code-block|syntax|javascript|1414976|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/multiprocessing.html#module-multiprocessing|1|http://docs.python.org/library/multiprocessing.html#using-a-pool-of-workers^0|Z|F|0|0|0|E|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|F|3|G|5|H|7|12|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

python is not a particularly functional language, and with the GIL, it's not very parallel, either, but combined with the <a href="http://docs.python.org/library/multiprocessing.html#module-multiprocessing" rel="nofollow noreferrer">multiprocessing</a> module (standard since 2.6), you get both, but it's not quite as elegant as pure functional languages. 

<a href="http://docs.python.org/library/multiprocessing.html#using-a-pool-of-workers" rel="nofollow noreferrer">Brief example:</a> 

<pre><code>from multiprocessing import Pool

def f(x):
 return x*x

if __name__ == '__main__':
 pool = Pool(processes=4) # start 4 worker processes
 result = pool.apply_async(f, [10]) # evaluate "f(10)" asynchronously
 print result.get(timeout=1) # prints "100" unless your computer is *very* slow
 print pool.map(f, range(10)) # prints "[0, 1, 4,..., 81]"
</code></pre>

The OCaml GC imposes a global lock that prevents mutators (threads) from running in parallel although they can run concurrently (interleaved). I believe the same is true of SML/NJ and MLton but not PolyML, GHC, F#, Clojure and Scala.

What other functional language implementations allow threads to run in parallel?

What functional language implementations allow threads to run in parallel?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

OCaml GC强加了一个全局锁，该全局锁阻止修改器(线程)并行运行，尽管它们可以并发(交错)运行。我相信这同样适用于SML/NJ和MLton，但不适用于PolyML、GHC、F#、Clojure和Scala。还有哪些函数式语言实现允许线程并行运行？

问哪些函数式语言实现允许线程并行运行？
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问哪些函数式语言实现允许线程并行运行？EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问哪些函数式语言实现允许线程并行运行？
EN