• 并发
    • Future
    • Delay
    • Promise
    • Atom
    • Watch
    • Validator
    • Ref
    • Dynamic var

    并发

    Clojure是一门支持并发编程的语言，它提供了很多特性让我们非常的方便进行并发程序的开发。

    Future

    Future可以让我们在另一个线程去执行任务，它是异步执行的，所以调用了future之后会立即返回。譬如：

    1. user=> (future (Thread/sleep 3000) (println "I'am back")) 
    2. #object[clojure.core$future_call$reify__6736 0x7118d905 {:status :pending, :val nil}]
    3. user=> (println "I'am here")
    4. I'am here
    5. nil
    6. user=> I'am back

    在上面的例子中，sleep会阻塞当前线程的执行，但是因为我们用了future，所以clojure将其放到了另一个线程中，然后继续执行下面的语句。

    有时候，我们使用了future之后，还需要知道future的任务执行的结果，知识后就需要用defer来实现了。我们可以使用defer或者@来获取future的result，譬如：

    1. user=> (let [result (future (println "run only once") (+ 1 1))]
    2.   #_=> (println (deref result))
    3.   #_=> (println @result))
    4. run only once
    5. 2
    6. 2
    7. nil

    deref还可以支持timeout设置，如果超过了等待时间，就返回一个默认值。

    1. user=> (deref (future (Thread/sleep 100) 0) 10 5)
    2. 5
    3. user=> (deref (future (Thread/sleep 100) 0) 1000 5)
    4. 0

    我们也可以使用realized?来判断一个future是否完成

    1. user=> (realized? (future (Thread/sleep 1000)))
    2. false
    3. user=> (let [f (future)]
    4.   #_=> @f
    5.   #_=> (realized? f))
    6. true

    Delay

    Delay可以让我们定义一个稍后执行的任务，并不需要现在立刻执行。

    1. user=> (def my-delay
    2.   #_=> (delay (let [msg "hello world"]
    3.   #_=> (println msg)
    4.   #_=> msg)))
    5. #'user/my-delay

    我们可以通过@或者force来执行delay的任务

    1. user=> @my-delay
    2. hello world
    3. "hello world"
    4. user=> (force my-delay)
    5. "hello world"

    Clojure会将delay的任务结果缓存，所以第二次delay的调用我们直接获取的是缓存结果。

    我们可以将delay和future一起使用，定义一个delay操作，在future完成之后，调用delay，譬如：

    1. user=> (let [notify (delay (println "hello world"))]
    2.   #_=> (future ((Thread/sleep 1000) (force notify))))
    3. #object[clojure.core$future_call$reify__6736 0x2de625f3 {:status :pending, :val nil}]
    4. user=> hello world

    Promise

    Promise是一个承诺，我们定义了这个promise，就预期后续会得到相应的result。我们通过deliver来将result发送给对应的promise，如下：

    1. user=> (def my-promise (promise))
    2. #'user/my-promise
    3. user=> (deliver my-promise (+ 1 1))
    4. #object[clojure.core$promise$reify__6779 0x30dc687a {:status :ready, :val 2}]
    5. user=> @my-promise
    6. 2

    promise也跟delay一样，会缓存deliver的result

    1. user=> (deliver my-promise (+ 1 2))
    2. nil
    3. user=> @my-promise
    4. 2

    我们也可以将promise和future一起使用

    1. user=> (let [hello-promise (promise)]
    2.   #_=> (future (println "Hello" @hello-promise))
    3.   #_=> (Thread/sleep 1000)
    4.   #_=> (deliver hello-promise "world"))
    5. Hello world

    Atom

    在并发编程里面，a = a + 1这条语句并不是安全的，在clojure里面，我们可以使用atom完成一些原子操作。如果大家熟悉c语言里面的compare and swap那一套原子操作函数，其实对Clojure的atom也不会陌生了。

    我们使用atom创建一个atom，然后使用@来获取这个atom当前引用的值:

    1. user=> (def n (atom 1))
    2. #'user/n
    3. user=> @n
    4. 1

    如果我们需要更新该atom引用的值，我们需要通过一些原子操作来完成，譬如：

    1. user=> (swap! n inc)
    2. 2
    3. user=> @n
    4. 2
    5. user=> (reset! n 0)
    6. 0
    7. user=> @n
    8. 0

    Watch

    对于一些数据的状态变化，我们可以使用watch来监控，一个watch function包括4个参数，关注的key，需要watch的reference，譬如atom等，以及该reference之前的state以及新的state，譬如：

    1. user=> (defn watch-n
    2.   #_=> [key watched old-state new-state]
    3.   #_=> (if (> new-state 1)
    4.   #_=> (println "new" new-state)
    5.   #_=> (println "old" old-state)))
    6. user=> (def wn (atom 1))
    7. #'user/wn
    8. user=> @wn
    9. 1
    10. user=> (add-watch wn :a watch-n)
    11. #object[clojure.lang.Atom 0x4b28dcf8 {:status :ready, :val 1}]
    12. user=> (reset! wn 1)
    13. old 1
    14. 1
    15. user=> (reset! wn 2)
    16. new 2
    17. 2

    Validator

    我们可以使用validator来验证某个reference状态改变是不是合法的，譬如：

    1. user=> (defn validate-n
    2.   #_=> [n]
    3.   #_=> (> n 1))
    4. #'user/validate-n
    5. user=> (def vn (atom 2 :validator validate-n))
    6. #'user/vn
    7. user=> (reset! vn 10)
    8. 10
    9. user=> (reset! vn 0)
    11. IllegalStateException Invalid reference state  clojure.lang.ARef.validate (ARef.java:33)

    在上面的例子里面，我们建立了一个validator，参数n必须大于1，否则就是非法的。

    Ref

    在前面，我们知道使用atom，能够原子操作某一个reference，但是如果要操作一批atom，就不行了，这时候我们就要使用ref。

    1. user=> (def x (ref 0))
    2. #'user/x
    3. user=> (def y (ref 0))
    4. #'user/y

    我们创建了两个ref对象x和y，然后在dosync里面对其原子更新

    1. user=> (dosync 
    2.   #_=> (ref-set x 1)
    3.   #_=> (ref-set y 2)
    4.   #_=> )
    5. 2
    6. user=> [@x @y]
    7. [1 2]
    8. user=> (dosync 
    9.   #_=> (alter x inc)
    10.   #_=> (alter y inc))
    11. user=> (dosync 
    12.   #_=> (commute x inc)
    13.   #_=> (commute y inc))

    ref-set就类似于atom里面的reset!，alter就类似swap!，我们可以看到，还有一个commute也能进行reference的更新，它类似于alter，但是稍微有一点不一样。

    在一个事务开始之后，如果使用alter，那么在修改这个reference的时候，alter会去看有没有新的修改，如果有，就会重试当前事务，而commute则没有这样的检查。所以如果通常为了性能考量，并且我们知道程序没有并发的副作用，那就使用commute，如果有，就老老实实使用alter了。

    我们通过@来获取reference当前的值，在一个事务里面，我们通过ensure来保证获取的值一定是最新的:

    1. user=> (dosync 
    2.   #_=> (ref-set x (ensure y)))

    Dynamic var

    通常我们通过def定义一个变量之后，最好就不要更改这个var了，但是有时候，我们又需要在某些context里面去更新这个var的值，这时候，最好就使用dynamic var了。

    我们通过如下方式定义一个dynamic var:

    1. user=> (def ^:dynamic *my-var* "hello")
    2. #'user/*my-var*

    dynamic var必须用*包裹，在lisp里面，这个叫做earmuffs，然后我们就能够通过binding来动态改变这个var了:

    1. user=> (binding [*my-var* "world"] *my-var*)
    2. "world"
    3. user=> (println *my-var*)
    4. hello
    5. user=> (binding [*my-var* "world"] (println *my-var*)
    6.   #_=> (binding [*my-var* "clojure"] (println *my-var*)) (println *my-var*))
    7. world
    8. clojure
    9. world

    可以看到，binding只会影响当前的stack binding。