执行外部进程时，超时不适用于 F# Async.RunSynchronously

Question

Starting a potentially slow or hanging process with the code below, will not result in a timeout:

open System.Diagnostics

[<EntryPoint>]
let main argv =
    Async.RunSynchronously(
        async {
            use proc = Process.Start(@"SlowProcess.exe")
            proc.WaitForExit()
        }, timeout = 2000)
    0

The workaround is of course to use a timeout in the call to WaitForExit , but I'm curious about why the Async.RunSynchronously timeout doesn't work in this specific case.

Answer 1

The way cancellation in F# asynchronous workflows works is that it is collaborative - it will never forcefully kill the thread. It propagates the cancellation token automatically, passes it to operations that support that and checks for cancellation every time the F# async workflow infrastructure gets a chance (typically before running code using let! and after it completes). This means that blocking code is not cancelled. A smaller example that illustrates this would be:

let work = async {
    try
      printfn "Going to sleep"
      Thread.Sleep(10000)
      printfn "Waking up"  
    finally
      printfn "All completed"
  }

If you run this and cancel it immediately, it will print "Going to sleep" and then you'll only get "All completed" after 10 seconds - because the Thread.Sleep call is synchronous.

If you want to kill the process when the workflow is cancelled, you should be able to explicitly register a cancellation handler and use the Kill method to stop the process - I have not tested this (I don't have a suitable slow process around,): but something like this should do the trick:

let work = async {
    let! tok = Async.CancellationToken
    use proc = Process.Start(@"SlowProcess.exe")
    tok.Register(fun () -> proc.Kill()) |> ignore
    proc.WaitForExit()
  }