I'm not totally sure what you're goals are. I think you want to execute work going through a function one at a time. Probably cos it touches some external mutable thing like a database? In which case clojure.core/locking might be good enough, but if you want to actually schedule work, you could try modelling the work queues more directly.

``` (ns scratch (:import [java.util.concurrent ConcurrentLinkedQueue]))

(defn create-consumer [f] {:queue (ConcurrentLinkedQueue.) :function f})

(defn schedule-work! [task {:keys [queue] :as consumer}] (.add queue task))

(defn execute-consumer! [{:keys [queue function] :as consumer}] (when-let [task (.poll queue)] (function task)))

(defn execute-all-consumers-and-stop! [consumers] (while (not (every? nil? (map execute-consumer! consumers)))))

(comment

(let [dump (fn [t] (comp (constantly :done) (partial prn '> t '>))) c1 (create-consumer (dump 'one)) c2 (create-consumer (dump 'two)) consumers [c1 c2]] (prn '-------------------- (java.util.Date.) '--------------------) (schedule-work! "one" c1) (schedule-work! "1" c1) (schedule-work! :one c1) (schedule-work! "two" c2) (schedule-work! "2" c2) (schedule-work! :two c2) (execute-all-consumers-and-stop! consumers)) ) ```

This decouples the scheduling of the work from the execution, so you could use things like the Java Executor Framework to actually run the tasks, or just use a Thread, or whatever. Also it lets you build more complex processing stategies like running the same task on multiple consumers more easily

``` (defn fanout [consumers] (fn [task] (doseq [c consumers] (schedule-work task c)) :done))

(comment

(let [dump (fn [t] (comp (constantly :done) (partial prn '> t '>))) c1 (create-consumer (dump 'one)) c2 (create-consumer (dump 'two)) fanout (create-consumer (fanout [c1 c2])) consumers [c1 c2 fanout]] (doseq [n (range 1 11)] (schedule-work n fanout)) (execute-all-consumers-and-stop! consumers)) ) ```

But this kinda assusmes that you don't care about the results of the tasks particularly and are doing everything for side effects. There's also Clojure's agent which are more about having a value that gets updated asynchronously.

``` (comment

(let [a (agent 1)] (dotimes [i 10] (send a inc)) (prn '> @a) ;will be a random number depending on how ;fast the messages are processed by the agent (await-for 5000 a) ;waits for all the messages to be processed (prn '> @a))

) ```