user=> (def long-calculation (future (apply + (range 1e8))))
#'user/long-calculation
user=> (type long-calculation)
clojure.core$future_call$reify__6110
user=> @long-calculation
4999999950000000
user=> (deref long-calculation)
4999999950000000

user=> (def a (promise))
#'user/a
user=> (def b (promise))
#'user/b
user=> (def c (promise))
#'user/c
user=> (future
  (deliver c (+ @a @b))
  (println "Delivery complete!"))
#<core$future_call$reify__6110@74aa513b: :pending>
user=> (deliver a 101)
#<core$promise$reify__6153@23293541: 101>
user=> (deliver b 102)
Delivery complete!
#<core$promise$reify__6153@582b0e7b: 102>
user=>

user=> (source promise)
(defn promise
  "Alpha - subject to change.
  Returns a promise object that can be read with deref/@, and set,
  once only, with deliver. Calls to deref/@ prior to delivery will
  block, unless the variant of deref with timeout is used. All
  subsequent derefs will return the same delivered value without
  blocking. See also - realized?."
  {:added "1.1"
   :static true}
  []
  (let [d (java.util.concurrent.CountDownLatch. 1)
        v (atom d)]
    (reify
     clojure.lang.IDeref
       (deref [_] (.await d) @v)
     clojure.lang.IBlockingDeref
       (deref
        [_ timeout-ms timeout-val]
        (if (.await d timeout-ms java.util.concurrent.TimeUnit/MILLISECONDS)
          @v
          timeout-val))
     clojure.lang.IPending
      (isRealized [this]
       (zero? (.getCount d)))
     clojure.lang.IFn
     (invoke
      [this x]
      (when (and (pos? (.getCount d))
                 (compare-and-set! v d x))
        (.countDown d)
        this)))))

  Task.Factory.StartNew(() => { Console.WriteLine("Hello Parallel Program."); });
 
       Parallel.For(0, 100, (index) =>
                                        {
                                        index.Dump();
                                        });
 
      //Console.WriteLine("Hello Parallel Program.");被外包到其它线程的进行计算,Task背后的实现是进程池.
 
      //下面这个例子使用了Lazy
      Lazy<Task<string>> lazyTask = new Lazy<Task<string>>(() =>
            {
                return new Task<string>(() => { Console.WriteLine("Task Body working......"); return "Task Result"; });
            });
 
      Console.WriteLine("Calling lazy variable");
      Console.WriteLine("Result from task: {0}", lazyData.Value.Result);