Clojure concurrency and some niceties

I stumbled upon the barber problem at some webpage I don't remember; it was a loose and open approach to it. I then imagined my own version and implemented that in Clojure (I'll put the code as a Gist, even though the style just does not match this blog's). Basically, I want to adjust the rate of customers entering the barber shop to a little faster than the barber can dispatch one customer.

To do that, I create two functions, one that increases the queue of customers (with the shop supporting up to 3 customers) amd one that dispatces customers, decreasing the queue. I assume 4 hours for customers to be able to take a seat (the barber's will close after 4 hours and cut the remaining wating customers).

	(ns barber-2)
	(def seats 3)
	(def max-time (* 4 3600) )
	(def queue (ref 0))
	(def total (ref 0))
	(defn customer-enter [t]
	(let [f (if (< @queue 3) inc identity)]
	(dosync (alter queue f)) ))
	(defn barber-work [k r o n]
	(if (>= n o)
	(let [rnd (. (java.util.Random. ) nextInt 200)]
	(if (< rnd 150)
	(dosync
	(println "Queue: " @queue)
	(alter queue dec)
	(alter total inc) )))))
	(add-watch queue 0 barber-work)
	(defn cut []
	(loop [t max-time]
	(if (> t 0)
	(let [interval (+ 1200 (. (java.util.Random. ) nextInt (* 10 60)) )]
	(java.lang.Thread/sleep interval)
	(customer-enter interval)
	(println t)
	(recur (- t interval) ) ))))
	(cut)
	(println "Total haircuts: " @total)

view raw barber2.clj hosted with ❤ by GitHub

Notice here that the barber cuts the hair only if a random number meets a condition (here making him slower than his customers). I implement this with a watcher function, that gets called whenever the reference changes. In order to be called every time a customer enter the shop, we need to issue and identity change, that does not change the value of the queue but fires the watcher. This is a very nice feature of Clojure.

The important functional element is this

  (let [f (if (< @queue 3) inc identity)]
    (dosync (alter queue f)) ))

Notice the conditional assignment to the variable in the let block. This removes the boilerplate code needed in the expression section within the let block.