Back to Questions
3.3k
views1
comment
Question on using locks with async workflows
f#workflowsasync

Hi,

I wanted to use locks to make sure the files to which I was writing weren't being accessed otherwise, and used the following code, which didn't work when called several times in a row, raising an unhandled exception : "attempt to release a mutex not owned by caller thread". Is there a way to synchronize ?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

 

#light

module Logging

open System.IO
open System.Threading

open Microsoft.FSharp.Control.Async
open Microsoft.FSharp.Control.CommonExtensions
open Microsoft.FSharp.Control.Mailboxes

open Common.Async.Mailbox // just for the <-- operator
    
type Level =
  | Warning
  | FatalError 
  | Information
    
type Entry =
  { timestamp: System.DateTime;
    level: Level;
    message: string;
  }
  with
    static member make ts level msg =
      { timestamp = ts
        level = level
        message = msg
      }

let log_file_lock = new ReaderWriterLock()

let logger  =
  MailboxProcessor.Start(fun inbox ->
    let rec loop() =
      async 
        { let! (path, entry) = inbox.Receive()
          let level = any_to_string entry.level 
          let msg = "[" + entry.timestamp.ToString() + "]\t" +"[" + level + "]\t" + entry.message + "\n" |> ByteString.of_string //this just converts the string into a byte array using UTF8 encoding
          if not (File.Exists(path)) then use stream = File.Create(path) in do ()
          do log_file_lock.AcquireWriterLock(Timeout.Infinite)        
          try 
            use stream = File.OpenWrite(path)
            do! stream.WriteAsync(msg) 
          finally
            log_file_lock.ReleaseWriterLock() 
          
          return! loop()             
        }
    loop()
  )

let log_extended path timestamp level msg = logger <-- (path, Entry.make timestamp level msg)

let log path level msg = log_extended path System.DateTime.Now level msg

and the calling bit :

1
2
3
4
5

let _ =
  for i in 0 .. 100 do
    P2P.Logging.log ("c:\\log.txt"]) Logging.Level.Information "this is a piece of information"
  read_line()

Thank you for your help !

.

The "finally" block in an async workflow will not normally run on the same thread as the code before the "try".

Both Mutex and ReaderWriterLock have OS thread affinity (they must use thread local store underneath), Using a Semaphore works:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

 

let log_file_lock = new Semaphore(1,1)

let logger  =
  MailboxProcessor.Start(fun inbox ->
    let rec loop() =
      async 
        { let! (path, entry) = inbox.Receive()
          let level = any_to_string entry.level 
          let msg = "[" + entry.timestamp.ToString() + "]\t" +"[" + level + "]\t" + entry.message 
          do printfn "acquiring..."
          let! _ = log_file_lock.WaitOneAsync(Timeout.Infinite) 
          do printfn "acquired..."
          try 
            if not (File.Exists(path)) then 
                use stream = File.Create(path) 
                do ()
            use stream = File.AppendText(path)
            do stream.WriteLine(msg) 
          finally
            try log_file_lock.Release() |> ignore 
            with e -> printfn "fail!, e = %A" e
          
          return! loop()             
        }
    loop()
  )

let log_extended path timestamp level msg = logger.Post((path, Entry.make timestamp level msg))

let log path level msg = log_extended path System.DateTime.Now level msg
By on 12/2/2007 7:26 PM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper