在完成期间MailboxProcessor崩溃

Question

This code is running on Mono (5.4.1.7).

I'm using F#'s Agents to handle a lot of data processing in my web application, and one of these messages is Shutdown. When a posted Shutdown message is processed, the agent cleans up some things and stops its message loop. This works fine and dandy, but blows up in my face if I try to perform a Shutdown from Finalize() . I've managed to reproduce this:

open System
open System.Threading

type ConsoleMessage =
    | Clear
    | Println of string
    // Reply back (with unit) so that calling code is able to wait for the agent to clean up (for code dependent on the
    // agent's resources definitely being released and such)
    | Shutdown of AsyncReplyChannel<unit>

type ConsoleAgent() =
    let mutable disposed = false
    let mutable stopped = false

    let agent = MailboxProcessor.Start(fun agent ->
        let rec messageLoop () = async {
            let! message = agent.Receive ()
            match message with
            | Clear -> System.Console.Clear ()
            | Println str -> printfn "%s" str
            | Shutdown rc ->
                // Cleanup goes here
                printfn "Shutting Down"
                stopped <- true
                rc.Reply ()
            System.Threading.Thread.Sleep 100
            if not stopped then
                return! messageLoop () }
        messageLoop ())

    member this.Post msg = agent.Post msg

    member this.PostAndAsyncReply msg = agent.PostAndAsyncReply msg

    member this.Dispose disposing =
        printfn "Disposing (disposing = %b)" disposing
        if not disposed then
            Async.RunSynchronously (agent.PostAndAsyncReply Shutdown)
            disposed <- true

    override this.Finalize () =
        this.Dispose false

    interface IDisposable with
        member this.Dispose () =
            this.Dispose true

module Main =
    [<EntryPoint>]
    let main args =
        let console = new ConsoleAgent()
        console.Post (Println "Print 1")
        console.Post (Println "Print 2")
        Thread.Sleep 1000
        0

Of course in the real application they have nothing to do with console printing.

Here's the stacktrace I get:

Unhandled Exception:
System.NullReferenceException: Object reference not set to an instance of an object
  at System.Runtime.Remoting.Contexts.SynchronizationAttribute.EnterContext () [0x00000] in /Users/builder/data/lanes/4992/mono-mac-sdk/external/bockbuild/builds/mono-x64/mcs/class/corlib/System.Runtime.Remoting.Contexts/SynchronizationAttribute.cs:184 
  at System.Threading.WaitHandle.WaitOneNative (System.Runtime.InteropServices.SafeHandle waitableSafeHandle, System.UInt32 millisecondsTimeout, System.Boolean hasThreadAffinity, System.Boolean exitContext) [0x0002d] in /Users/builder/data/lanes/4992/mono-mac-sdk/external/bockbuild/builds/mono-x64/mcs/class/corlib/System.Threading/WaitHandle.cs:111 
  at System.Threading.WaitHandle.InternalWaitOne (System.Runtime.InteropServices.SafeHandle waitableSafeHandle, System.Int64 millisecondsTimeout, System.Boolean hasThreadAffinity, System.Boolean exitContext) [0x00014] in /Users/builder/data/lanes/4992/mono-mac-sdk/external/bockbuild/builds/mono-x64/mcs/class/referencesource/mscorlib/system/threading/waithandle.cs:250 
  at System.Threading.WaitHandle.WaitOne (System.Int64 timeout, System.Boolean exitContext) [0x00000] in /Users/builder/data/lanes/4992/mono-mac-sdk/external/bockbuild/builds/mono-x64/mcs/class/referencesource/mscorlib/system/threading/waithandle.cs:239 
  at System.Threading.WaitHandle.WaitOne (System.Int32 millisecondsTimeout, System.Boolean exitContext) [0x00019] in /Users/builder/data/lanes/4992/mono-mac-sdk/external/bockbuild/builds/mono-x64/mcs/class/referencesource/mscorlib/system/threading/waithandle.cs:206 
  at Microsoft.FSharp.Control.AsyncImpl+ResultCell`1[T].TryWaitForResultSynchronously (Microsoft.FSharp.Core.FSharpOption`1[T] timeout) [0x0002a] in <5a7d678a904cf4daa74503838a677d5a>:0 
  at Microsoft.FSharp.Control.CancellationTokenOps.RunSynchronouslyInCurrentThread[a] (System.Threading.CancellationToken token, Microsoft.FSharp.Control.FSharpAsync`1[T] computation) [0x0001c] in <5a7d678a904cf4daa74503838a677d5a>:0 
  at Microsoft.FSharp.Control.CancellationTokenOps.RunSynchronously[a] (System.Threading.CancellationToken token, Microsoft.FSharp.Control.FSharpAsync`1[T] computation, Microsoft.FSharp.Core.FSharpOption`1[T] timeout) [0x00013] in <5a7d678a904cf4daa74503838a677d5a>:0 
  at Microsoft.FSharp.Control.FSharpAsync.RunSynchronously[T] (Microsoft.FSharp.Control.FSharpAsync`1[T] computation, Microsoft.FSharp.Core.FSharpOption`1[T] timeout, Microsoft.FSharp.Core.FSharpOption`1[T] cancellationToken) [0x00070] in <5a7d678a904cf4daa74503838a677d5a>:0 
  at Program+ConsoleAgent.Dispose (System.Boolean disposing) [0x00027] in /Users/jwostenberg/Code/FSharp/Sandbox/Sandbox/Program.fs:38 
  at Program+ConsoleAgent.Finalize () [0x00000] in /Users/jwostenberg/Code/FSharp/Sandbox/Sandbox/Program.fs:42 

What's more, this doesn't happen if the object is disposed properly via the dispose pattern (eg change let console = new ConsoleAgent() to use console = new ConsoleAgent() ). I can't really do this in my own code without bending over backwards because I don't have direct references to these agents (there are many of them running at a time), but shouldn't I be able to let them dispose via the garbage collector anyways?

Is this my fault, F#'s fault, or Mono's fault? For now, I've wrapped the relevant part of the Dispose() method in a try/catch that just logs the exception, but this feels really dirty.

Answer 1

There are very few scenarios where you need to override Finalize , and it doesn't look like your use case applies. See "Notes for implementers" section here and this entire article .

The Object.Finalize method does nothing by default, but you should override Finalize only if necessary, and only to release unmanaged resources.

Re: your comment:

How do you ensure that the MailboxProcessor message loop is shut down without Finalize ?

You could just use the IDisposable pattern, or manage the lifetimes of your MailboxProcessor s more explicitly which may require refactoring your project.

I can't really do this in my own code without bending over backwards because I don't have direct references to these agents (there are many of them running at a time), but shouldn't I be able to let them dispose via the garbage collector anyways?

Yes, you should be able to let them dispose "naturally" assuming they don't own unmanaged resources. It's hard to say without seeing the real-world use case, but it sounds like you want more control over the lifetimes of the processors. This might be somewhat of a XY problem .

Answer 2

The argument "disposing" of the method Dispose is here for reason. It differentiates between managed and unmanaged applications of Dispose. In brief, Dispose(true) means that this call is explicit (using statement or F#'s use ). It is basically continuation of "normal" .NET programming.

Dispose(false) means that finalisation is happening. This means that any referenced .NET objects can be either alive, disposed, or finalised. So your code is need to care about unmanaged resources only and do not try to call or use in any other way managed objects.

It is important, that Dispose() is not called automatically, while finaliser is. Making the example correct requires two changes:

• explicitly control state of the disposable object
• send message only when the object is disposed, not finalised

Code:

    member this.Dispose disposing =
        if disposing && not disposed then
            Async.RunSynchronously (agent.PostAndAsyncReply Shutdown)
            disposed <- true

module Main =
    [<EntryPoint>]
    let main args =
        use console = new ConsoleAgent()
        Thread.Sleep 1000
        0