Clojure是一门支持并发编程的语言，它提供了很多特性让我们非常的方便进行并发程序的开发。
Future
Future可以让我们在另一个线程去执行任务，它是异步执行的，所以调用了future之后会立即返回。譬如：
user=> (future (Thread/sleep 3000) (println "I'am back"))
#object[clojure.core$future_call$reify__6736 0x7118d905 {:status :pending, :val nil}]
user=> (println "I'am here")
I'am here
nil
user=> I'am back
在上面的例子中，sleep会阻塞当前线程的执行，但是因为我们用了future，所以clojure将其放到了另一个线程中，然后继续执行下面的语句。
有时候，我们使用了future之后，还需要知道future的任务执行的结果，知识后就需要用defer来实现了。我们可以使用defer或者@来获取future的result，譬如：
user=> (let [result (future (println "run only once") (+ 1 1))]
#_=> (println (deref result))
#_=> (println @result))
run only once
2
2
nil
deref还可以支持timeout设置，如果超过了等待时间，就返回一个默认值。
user=> (deref (future (Thread/sleep 100) 0) 10 5)
5
user=> (deref (future (Thread/sleep 100) 0) 1000 5)
0
我们也可以使用realized?来判断一个future是否完成
user=> (realized? (future (Thread/sleep 1000)))
false
user=> (let [f (future)]
#_=> @f
#_=> (realized? f))
true
Delay
Delay可以让我们定义一个稍后执行的任务，并不需要现在立刻执行。
user=> (def my-delay
#_=> (delay (let [msg "hello world"]
#_=> (println msg)
#_=> msg)))
#'user/my-delay
我们可以通过@或者force来执行delay的任务
user=> @my-delay
hello world
"hello world"
user=> (force my-delay)
"hello world"
Clojure会将delay的任务结果缓存，所以第二次delay的调用我们直接获取的是缓存结果。
我们可以将delay和future一起使用，定义一个delay操作，在future完成之后，调用delay，譬如：
user=> (let [notify (delay (println "hello world"))]
#_=> (future ((Thread/sleep 1000) (force notify))))
#object[clojure.core$future_call$reify__6736 0x2de625f3 {:status :pending, :val nil}]
user=> hello world
Promise
Promise是一个承诺，我们定义了这个promise，就预期后续会得到相应的result。我们通过deliver来将result发送给对应的promise，如下：
user=> (def my-promise (promise))
#'user/my-promise
user=> (deliver my-promise (+ 1 1))
#object[clojure.core$promise$reify__6779 0x30dc687a {:status :ready, :val 2}]
user=> @my-promise
2
promise也跟delay一样，会缓存deliver的result
user=> (deliver my-promise (+ 1 2))
nil
user=> @my-promise
2
我们也可以将promise和future一起使用
user=> (let [hello-promise (promise)]
#_=> (future (println "Hello" @hello-promise))
#_=> (Thread/sleep 1000)
#_=> (deliver hello-promise "world"))
Hello world
Atom
在并发编程里面，a = a + 1这条语句并不是安全的，在clojure里面，我们可以使用atom完成一些原子操作。如果大家熟悉c语言里面的compare and swap那一套原子操作函数，其实对Clojure的atom也不会陌生了。
我们使用atom创建一个atom，然后使用@来获取这个atom当前引用的值:
user=> (def n (atom 1))
#'user/n
user=> @n
1
如果我们需要更新该atom引用的值，我们需要通过一些原子操作来完成，譬如：
user=> (swap! n inc)
2
user=> @n
2
user=> (reset! n 0)
0
user=> @n
0
Watch
对于一些数据的状态变化，我们可以使用watch来监控，一个watch function包括4个参数，关注的key，需要watch的reference，譬如atom等，以及该reference之前的state以及新的state，譬如：
user=> (defn watch-n
#_=> [key watched old-state new-state]
#_=> (if (> new-state 1)
#_=> (println "new" new-state)
#_=> (println "old" old-state)))
user=> (def wn (atom 1))
#'user/wn
user=> @wn
1
user=> (add-watch wn :a watch-n)
#object[clojure.lang.Atom 0x4b28dcf8 {:status :ready, :val 1}]
user=> (reset! wn 1)
old 1
1
user=> (reset! wn 2)
new 2
2
Validator
我们可以使用validator来验证某个reference状态改变是不是合法的，譬如：
user=> (defn validate-n
#_=> [n]
#_=> (> n 1))
#'user/validate-n
user=> (def vn (atom 2 :validator validate-n))
#'user/vn
user=> (reset! vn 10)
10
user=> (reset! vn 0)
IllegalStateException Invalid reference state clojure.lang.ARef.validate (ARef.java:33)
在上面的例子里面，我们建立了一个validator，参数n必须大于1，否则就是非法的。
Ref
在前面，我们知道使用atom，能够原子操作某一个reference，但是如果要操作一批atom，就不行了，这时候我们就要使用ref。
user=> (def x (ref 0))
#'user/x
user=> (def y (ref 0))
#'user/y
我们创建了两个ref对象x和y，然后在dosync里面对其原子更新
user=> (dosync
#_=> (ref-set x 1)
#_=> (ref-set y 2)
#_=> )
2
user=> [@x @y]
[1 2]
user=> (dosync
#_=> (alter x inc)
#_=> (alter y inc))
user=> (dosync
#_=> (commute x inc)
#_=> (commute y inc))
ref-set就类似于atom里面的reset!，alter就类似swap!，我们可以看到，还有一个commute也能进行reference的更新，它类似于alter，但是稍微有一点不一样。
在一个事务开始之后，如果使用alter，那么在修改这个reference的时候，alter会去看有没有新的修改，如果有，就会重试当前事务，而commute则没有这样的检查。所以如果通常为了性能考量，并且我们知道程序没有并发的副作用，那就使用commute，如果有，就老老实实使用alter了。
我们通过@来获取reference当前的值，在一个事务里面，我们通过ensure来保证获取的值一定是最新的:
user=> (dosync
#_=> (ref-set x (ensure y)))
Dynamic var
通常我们通过def定义一个变量之后，最好就不要更改这个var了，但是有时候，我们又需要在某些context里面去更新这个var的值，这时候，最好就使用dynamic var了。
我们通过如下方式定义一个dynamic var:
user=> (def ^:dynamic *my-var* "hello")
#'user/*my-var*
dynamic var必须用*包裹，在lisp里面，这个叫做earmuffs，然后我们就能够通过binding来动态改变这个var了:
user=> (binding [*my-var* "world"] *my-var*)
"world"
user=> (println *my-var*)
hello
user=> (binding [*my-var* "world"] (println *my-var*)
#_=> (binding [*my-var* "clojure"] (println *my-var*)) (println *my-var*))
world
clojure
world
可以看到，binding只会影响当前的stack binding。