jiacai2050 / learn_clojure.mp4 Goto Github PK

(ns ^{:author "Jiacai Liu"
      :doc "https://segmentfault.com/l/1500000012456162"}
    demo.concurrency
  (:import java.util.concurrent.Executors))

(def nthread (+ 2 (.. Runtime getRuntime availableProcessors)))
(def executor (Executors/newFixedThreadPool nthread))

(defn do-job [workers]
  (doseq [f (.invokeAll executor workers)]
    (.get f)))

;; dynamic varbinding
(def ^:dynamic dynamic-var 123)
(do
  (println dynamic-var)
  (println (.. Thread currentThread getName))
  (future
    (binding [dynamic-var 321]
      (println (.. Thread currentThread getName))
      (println dynamic-var)))
  (println dynamic-var))

;; 很少用到，类似其他语言里面的变量
(with-local-vars [local-var 111]
  (println "test local var")
  (println (var-get local-var))
  (var-set local-var 222)
  (println (var-get local-var)))

;; Atom
(let [niters 10000
      magic-num (atom 1000)
      workers (map (fn [t]
                     (fn []
                       (dotimes [_ niters]
                         (swap! magic-num inc))))
                   (range nthread))]
  (do-job workers)
  (println "magic-num = " @magic-num))

;; Agent
(let [niters 10
      magic-num (agent 1000)
      worker (fn [n]
               (Thread/sleep 1)
               (inc n))]
  (set-agent-send-executor! executor)
  (dotimes [_ (* nthread niters)]
    (send magic-num worker)
    ;; IO operation
    (send-off magic-num worker)
    )

  (println "magic-num = " @magic-num)
  (await magic-num)
  (println "magic-num = " @magic-num))

;; Ref
(time (let [niters 10000
            run-times (atom 0)
            tom   (ref 100000)
            jerry (ref 100000)
            transfer (fn [amount]
                       (dosync
                        (swap! run-times inc)
                        (commute tom + amount)
                        ;; (alter tom + amount)
                        (alter jerry - amount)
                        ))
            workers (map (fn [t]
                           (fn []
                             (dotimes [_ niters]
                               (transfer t))))
                         (range nthread))]
        (doseq [f (.invokeAll executor workers)]
          (.get f))
        (println (format "tom = %s, jerry = %s, sum = %s, run-times = %s"
                         @tom @jerry (+ @tom @jerry) @run-times))))

(ns ^{:author "Jiacai Liu"
      :doc "https://segmentfault.com/l/1500000012556115"}
    demo.macro)

;; quote syntax-quote unquote splicing-unquote
;; 控制 symbol/list 求值时的行为
(let [x '(* 2 3) y x]
  (println `y)
  (println ``y)
  (println ``~y)
  (println ``~~y)
  (println (eval ``~~y))
  (println `(~@y))
  (println `(~y)))

(defmacro nothing [params]
  (println params (type params)))

(nothing x)

;; 一个简单的宏使用示例
(macroexpand-1 '(when (even? (rand-int 100))
                  (println "good luck!")
                  (println "lisp rocks!")))

;; 辅助函数
(defn prime? [n]
  (let [guard (int (Math/ceil (Math/sqrt n)))]
    (loop [i 2]
      (if (zero? (mod n i))
        false
        (if (= i guard)
          true
          (recur (inc i)))))))

(defn next-prime [n]
  (if (prime? n)
    n
    (recur (inc n))))

;; do-primes 基本形式
(defmacro do-primes [[variable start end] & body]
  `(loop [~variable ~start]
     (when (< ~variable ~end)
       (when (prime? ~variable)
         ~@body)
       (recur (next-prime (inc ~variable))))))

;; (doseq [a (range 10)]
;;   (println a))
(do-primes [n 2 (rand-int 10)] ;; [2, 13)
           (println n))

(def start 1)
;; 使用 gensym 保证宏卫生
(defmacro do-primes2 [[variable start end] & body]
  `(let [start# ~start
         end# ~end]
     (loop [~variable start#]
       (when (< ~variable end#)
         (when (prime? ~variable)
           ~@body)
         (recur (next-prime (inc ~variable)))))))

(do-primes2 [n 2 (rand-int 10)] ;; [2, 13)
            (println n))

(defmacro do-primes2-danger [[variable start end] & body]
  `(let [inner-start ~start
         inner-end ~end]
     (loop [~variable inner-start]
       (when (< ~variable inner-end)
         (when (prime? ~variable)
           ~@body)
         (recur (next-prime (inc ~variable)))))))

(macroexpand-1 '(do-primes2 [n 2 (+ 10 (rand-int 30))]
                                  (println n)))
(do-primes2-danger [n 2 (+ 10 (rand-int 30))]
                   (println n))
;; ~(quote inner-start)
(defmacro do-primes2-safe [[variable start end] & body]
  `(let [~'inner-start ~start
         ~'inner-end ~end]
     (loop [~variable ~'inner-start]
       (when (< ~variable ~'inner-end)
         (when (prime? ~variable)
           ~@body)
         (recur (next-prime (inc ~variable)))))))

(do-primes2-safe [n 2 (+ 10 (rand-int 30))]
                 (println n))


;; 宏嵌套宏
(defmacro only-once [names & body]
  (let [gensyms (repeatedly (count names) gensym)]
    (println "mmm")
    `(let [~@(interleave gensyms (repeat '(gensym)))]
       (println "nnn")
       `(let [~~@(mapcat #(list %1 %2) gensyms names)]
          (println "xxx")
          ~(let [~@(mapcat #(list %1 %2) names gensyms)]
             (println "yyy")
             ~@body)))))

(defmacro do-primes3 [[variable start end] & body]
  (only-once [start end]
             `(loop [~variable ~start]
                (when (< ~variable ~end)
                  (when (prime? ~variable)
                    ~@body)
                  (recur (next-prime (inc ~variable)))))))

(do-primes3 [n 2 (+ 10 (rand-int 30))]
           (println n))

;; 使用辅助函数来定义宏
(defmacro def-watched [name & value]
  `(do
     (def ~name ~@value)
     (add-watch (var ~name)
                :re-bind
                (fn [~'key ~'r old# new#]
                  (println '~name old# " -> " new#)))))
(def-watched foo 1)                  
(def foo 2)


(defmacro gen-watch-fn [name]
  (fn [k r o n]
    (println name ":" o " -> " n)))

(defmacro def-watched2 [name & value]
  `(do
     (def ~name ~@value)
     (add-watch (var ~name)
                :re-bind (gen-watch-fn '~name))))

(def-watched2 bar 1)                  
(def-watched2 bar 2)