F# Async如何实现Boost asio strands的等价功能？

Great question! When I was porting some async C++ code that relied on Boost.Asio strands to F#, I ran into exactly the same need. The good news is F# gives you a couple of idiomatic ways to ensure a set of Async workflows never run concurrently—here are the two approaches I’ve used successfully:

1. Use MailboxProcessor (F#'s built-in message queue) #

MailboxProcessor is designed to process messages one at a time on a single logical thread, which makes it a perfect analog to a Boost.Asio strand. You can wrap it into a Strand type that accepts Async tasks and executes them sequentially:

open System.Threading.Tasks

type AsyncCompletionSource<'T>() =
    let tcs = TaskCompletionSource<'T>()
    member _.SetResult result = tcs.SetResult result
    member _.SetException ex = tcs.SetException ex
    member _.Task = Async.AwaitTask tcs.Task

type Strand() =
    let mailbox = MailboxProcessor.Start(fun inbox ->
        let rec processTasks () = async {
            let! nextTask = inbox.Receive()
            do! nextTask
            return! processTasks ()
        }
        processTasks ()
    )

    // For fire-and-forget async tasks
    member _.Run (task: Async<unit>) =
        mailbox.Post task

    // For async tasks that return a result
    member _.RunAsync<'T> (task: Async<'T>) = async {
        let completion = AsyncCompletionSource<'T>()
        mailbox.Post <| async {
            try
                let! result = task
                completion.SetResult result
            with ex ->
                completion.SetException ex
        }
        return! completion.Task
    }

How to use it:

let myStrand = Strand()

// All these tasks will run sequentially, never concurrently
async {
    do! myStrand.RunAsync (async { printfn "Task 1 started"; do! Async.Sleep 1000; printfn "Task 1 finished" })
    do! myStrand.RunAsync (async { printfn "Task 2 started"; do! Async.Sleep 1000; printfn "Task 2 finished" })
} |> Async.Start

This approach is great if you need more than just serialization—you can extend the MailboxProcessor to handle task cancellation, priority queuing, or other custom logic later.

2. Use an AsyncLock (lightweight synchronization) #

If you don’t need the flexibility of a message queue, an AsyncLock (from the FSharp.Control.AsyncEx NuGet package, or a custom implementation) is a simpler option. AsyncLock is designed for async workflows, so it doesn’t block threads like a regular lock statement:

open FSharp.Control

type Strand() =
    let asyncLock = AsyncLock()

    member _.RunAsync<'T> (task: Async<'T>) = async {
        // Acquire the lock asynchronously
        use! _ = asyncLock.LockAsync()
        // The task runs exclusively here—no other task from the same Strand will execute concurrently
        return! task
    }

How to use it:

let myStrand = Strand()

async {
    let! result1 = myStrand.RunAsync (async { return "Result from task 1" })
    let! result2 = myStrand.RunAsync (async { return "Result from task 2" })
    printfn "%s, %s" result1 result2
} |> Async.Start

This is ideal for simple serialization needs—it’s less code and has lower overhead than a MailboxProcessor.

Both approaches guarantee that any Async workflows sent to the same Strand instance will never run in parallel, just like Boost.Asio strands. For state machines, you’d attach all your state-modifying async handlers to the same Strand, and you can safely update state without worrying about concurrent access, just like in a single-threaded environment.

内容的提问来源于stack exchange，提问作者justinpc