idiomatic file locking in clojure?

I have a group of futures processing jobs from a queue that involve writing to files. What's the idiomatic way to make sure only one future accesses a par开发者_高级运维ticular file at a time?

---

How about using agents instead of locks to ensure this?

I think using agents to safe guard shared mutable state, regardless if it's in memory or on disk is more idiomatic in clojure than using locks.

If you create one agent at a time and send the access tries to the agents, you can ensure that only on thread at time accesses a given file.

For example like this:

(use 'clojure.contrib.duck-streams)

(defn file-agent [file-name]
  (add-watch (agent nil) :file-writer 
    (fn [key agent old new] 
      (append-spit file-name new))))

(defn async-append [file-agent content]
  (send file-agent (constantly content)))

then append your file through the agent:

(async-append "content written to file" (file-agent "temp-file-name"))

If you need synchronous usage of the file it could be achieved with await. Like this:

(defn sync-append [file-agent content]
  (await (send file-agent (constantly content))))

---

I would use the core Clojure function locking which is used as follows:

(locking some-object
  (do-whatever-you-like))

Here some-object could either be the file itself, or alternatively any arbitrary object that you want to synchronise on (which might make sense if you wanted a single lock to protect multiple files).

Under the hood this uses standard JVM object locking, so it's basically equivalent to a synchronized block of code in Java.

---

I don't think there is specific built-in function for this in Clojure but you can use standard java IO functions to do this. This would look something like this:

(import '(java.io File RandomAccessFile))

(def f  (File. "/tmp/lock.file"))
(def channel (.getChannel (RandomAccessFile. f "rw")))
(def lock (.lock channel))
(.release lock)
(.close channel)