CODEWITHSUNDEEP
asynchronousconcurrencyf#
justinpc
justinpc

Reputation: 825

F# Async: equivalent of Boost asio's strands

Boost's asio library allows the serialisation of asynchronous code in the following way. Handlers to asynchronous functions such as those which read from a stream, may be associated to a strand. A strand is associated with an "IO context". An IO context owns a thread pool. However many threads in the pool, it is guaranteed that no two handlers associated with the same strand are run concurrently. This makes it possible, for instance, to implement a state machine as if it were single-threaded, where all handlers for that machine serialise over a private strand.

I have been trying to figure out how this might be done with F#'s Async. I could not find any way to make sure that chosen sets of Async processes never run concurrently. Can anyone suggest how to do this?

Upvotes: 1

Views: 104

Answers (1)

Tomas Petricek
Tomas Petricek

Reputation: 243106

It would be useful to know what is the use case that you are trying to implement. I don't think F# async has anything that would directly map to strands and you would likely use different techniques for implementing different things that might all be implemented using strands.

For example, if you are concerend with reading data from a stream, F# async block lets you write code that is asynchronous but sequential. The following runs a single logical process (which might be moved between threads of a thread pool when you wait using let!):

let readTest () = async { 
  let fs = File.OpenRead(@"C:\Temp\test.fs")
  let buffer = Array.zeroCreate 10
  let mutable read = 1
  while read <> 0 do
    let! r = fs.AsyncRead(buffer, 0, 10)
    printfn "Read: %A" buffer.[0 .. r-1]
    read <- r }

readTest() |> Async.Start

If you wanted to deal with events that occur without any control (i.e. push based rather than pull based), for example, when you cannot ask the system to read next buffer of data, you could serialize the events using a MailboxProcessor. The following sends two messages to the agent almost at the same time, but they are processed sequentially, with 1 second delay:

let agent = MailboxProcessor.Start(fun inbox -> async {
  while true do 
    let! msg = inbox.Receive()
    printfn "Got: %s" msg
    do! Async.Sleep(1000)
})

agent.Post("hello")
agent.Post("world")

Upvotes: 2

Related Questions