F# 天生就是就异步和并行的料

做模型开发免不了要使用异步和并行计算，尤其在多核CPU的今天，更是如此，F#恰逢其时，天生就具备这种能力，先看一个例子。

open System

open System.Drawing

open System.Windows.Forms

open System.Threading

let r = Random()

let drawCurves (frm : Form) =

let x, y = frm.ClientSize.Width, frm.ClientSize.Height

let g = frm.CreateGraphics()

for i in 1..10 do

Thread.Sleep(300)

g.DrawCurve(Pens.Black, [|  for i in 1..5 -> Point(r.Next(x), r.Next(y)) |])

g.Dispose()

let drawRecs (frm : Form) =

let x, y = frm.ClientSize.Width, frm.ClientSize.Height

let g = frm.CreateGraphics()

for i in 1..10 do

Thread.Sleep(150)

g.DrawRectangle(Pens.Blue, r.Next(x), r.Next(y), r.Next(x/2), r.Next(y/2))

g.Dispose()

let drawElls (frm : Form) =

let x, y = frm.ClientSize.Width, frm.ClientSize.Height

let g = frm.CreateGraphics()

for i in 1..10 do

Thread.Sleep(150)

g.DrawEllipse(Pens.OrangeRed, r.Next(x), r.Next(y), r.Next(x/2), r.Next(y/2))

g.Dispose()

let frm1 = new Form(Text="随机图形", BackColor=Color.White)

frm1.DoubleClick.Add(fun e -> Async.RunSynchronously

(Async.Parallel ([ async { drawCurves frm1 };

async { drawRecs frm1 };

async { drawElls frm1 }

]))    |> ignore

)

Application.Run(frm1)

这是用F#编写的WinForm程序，是在Form上随机画矩形和椭圆和曲线，所不同是使用异步和并行方法实现的。

异步工作流

当使用.NET BCL的所有I/O操作的时候，有两个模型可用，同步模型和异步模型。异步模型是通过一个通用的编程模式来支持的，即成对出现的BeginXXX和 EndXXX方法。程序员通过调用BeginXXX来开始异步操作，这个方法开始执行后，就马上返回。而，程序员在得到异步操作已经结束的提醒后，必须调用EndXXX方法完成整个过程。这就是所谓的分两步实现异步操作。

而F#通过异步工作流来实现异步的，并不需要两步，只需要一步就行，这大大简化异步操作。

关键的 let! 异步绑定

在异步工作流中，一些表达式和操作是同步的，而另一些则是旨在以异步方式返回结果的较长时间的计算。 以异步方式调用一个方法时，使用let!，而不是普通的 let 绑定。 let! 的作用是允许在执行计算的同时，继续执行其他计算或线程。 在 let! 绑定的右侧返回后，异步工作流的剩余部分将继续执行。

在下面的代码示例中，函数 fetchAsync 将获取从 Web 请求返回的 HTML 文本。 fetchAsync 函数包含异步代码块。 在对异步基元的结果（此示例中为 AsyncDownloadString）执行绑定时，将使用 let!，而不是使用 let。

open System.Net

open Microsoft.FSharp.Control.WebExtensions

let urlList = [ "Microsoft.com", "http://www.microsoft.com/"

"MSDN", "http://msdn.microsoft.com/"

"Bing", "http://www.bing.com"

]

let fetchAsync(name, url:string) =

async {

try

let uri = new System.Uri(url)

let webClient = new WebClient()

let! html = webClient.AsyncDownloadString(uri)

printfn "Read %d characters for %s" html.Length name

with

| ex -> printfn "%s" (ex.Message);

}

let runAll() =

urlList

|> Seq.map fetchAsync

|> Async.Parallel

|> Async.RunSynchronously

|> ignore

runAll()

从这个例子可以看出，编写异步程序，跟编写同步程序差别不大，只是多了个let!和async块而已，多简单呢！

下面我们看看并行

F#使用Async.Parallel 方法构建一个工作流，将并行执行列表中的所有工作流。在执行时，由Async.Parallel组合而成的异步操作会通过一个等待计算的队列来逐步发起。Async.Parallel只能处理固定数量的任务，对于一边处理一边生成任务的情况不能胜任。换个方式来看，即Async.Parallel无法处理即时获得的消息──例如，除了取消任务之外，一个代理对象的工作进度是可以得到控制的。另外，F#还可以利用.NET的并行计算机制实现并行。

下面的例子是在一个随机3千万数组中求最大值代码，我们看看并行与串行比较结果。

open System

open System.Linq

open System.Diagnostics

let rand = System.Random()

let arr1 = [| for i in 0..1000000 -> float(rand.Next(1000000)) * rand.NextDouble() |]

let watch1 = Stopwatch()

watch1.Start()

let x = Seq.max arr1

watch1.Stop()

printfn "数组长度=%i, x=%.4f,  串行计算用时%i毫秒" arr1.Length x watch1.ElapsedMilliseconds

let watch2 = Stopwatch()

watch2.Restart()

let pArr1 = ParallelEnumerable.AsParallel arr1;

let x' = ParallelEnumerable.Max pArr1

watch2.Stop()

printfn "数组长度=%i, x=%.4f,  串行计算用时%i毫秒" arr1.Length x watch2.ElapsedMilliseconds

Console.ReadKey() |> ignore

在一台i3-2120CPU 3.3G惠普机器上运行的结果：

并行有性能明显优势。

那么是不是并行就一定比串行快呢？，我们把3千万的数组改为1百万的数组在看看结果：

很明显，并行反倒比串行慢！！！，这一点请大家一定要注意，不要想当然认为并行一定比串行快。