`clojure.core/future`¶

Type: macro Added: Clojure 1.1 Examples: 6 Runnable: 1

([& body])

Takes a body of expressions and yields a future object that will invoke the body in another thread, and will cache the result and return it on all subsequent calls to deref/@. If the computation has not yet finished, calls to deref/@ will block, unless the variant of deref with timeout is used. See also - realized?.

Examples¶

by gstamp on 2010-08-06 . May have evaluation errors.

by OnesimusUnbound on 2011-08-03

;; save the example in a script (e.g. test-future.clj) then run it in the console
;;
;; > clojure test-future.clj

(println "[Main] calculate the answer to life the universe and everything")

;; Used Thread/sleep to simulate long running process
(def what-is-the-answer-to-life
    (future 
        (println "[Future] started computation")
        (Thread/sleep 3000) ;; running for 3 seconds
        (println "[Future] completed computation")
        42))

(println "[Main] created future")

(Thread/sleep 1000)
(println "[Main] do other things while waiting for the answer")
(println "[Main] get the answer")
(println "[Main] the result" @what-is-the-answer-to-life)
(shutdown-agents)

;; You may get something like this
;;
;; [Main] calculate the answer to life, the universe and everything
;; [Future] started computation
;; [Main] created future
;; [Main] do other things while waiting for the answer
;; [Main] get the answer
;; [Future] completed computation
;; [Main] the result 42

;; Note: If you leave out the call to (shutdown-agents), the program
;; will on most (all?) OS/JVM combinations "hang" for 1 minute before
;; the process exits.  It is waiting for a thread created by the
;; future call to be shut down.  shutdown-agents will shut them down
;; immediately, or (System/exit <exit-status>) will exit immediately
;; without waiting for them to shut down.

;; This wait occurs even if you use futures indirectly through some other Clojure
;; functions that use them internally, such as pmap or clojure.java.shell/sh

;; http://dev.clojure.org/jira/browse/CLJ-124 is a ticket opened against Clojure,
;; as this 1-minute wait is not considered desirable behavior.

by mattvvhat on 2015-04-09 . May have evaluation errors.

by tomgeorge on 2020-05-22 . May have evaluation errors.

by loeschzwerg on 2022-04-29 . May have evaluation errors.

;; You may want to do some cleanup whenever you cancel your `future`
;; InterruptedException is the catch!

;; lets say we want to feed our doge, but only a limited time...
(defn connect! [conn] (println (reset! conn "[doge] very yum")))
(defn response [conn] (println (reset! conn "[doge] so full")))
(defn clean    [conn] (println (reset! conn "[doge] so hungry")))

(let [feed-time  (rand-int 2000)
      connection (atom "[doge] such ready")
      doge-ops   (future
                   (try
                     (println @connection)
                     (connect! connection)
                     (Thread/sleep 1000)
                     (response connection)
                     (catch InterruptedException ie
                       (clean connection))
                     (finally (println "[doge] wow"))))]
  (printf "[Main] granting many feeding time: %dms\n" feed-time)
  (if (= :too-late (deref doge-ops feed-time :too-late))
    (do (println "[Main] stop!")
        (future-cancel doge-ops))
    @doge-ops))

;; if he's lucky:
[Main] granting many feeding time: 1582ms
[doge] such ready
[doge] very yum
[doge] so full
[doge] wow
=> nil

;; if he's unlucky:
[Main] granting many feeding time: 569ms
[doge] such ready
[doge] very yum
[Main] stop!
=> true
[doge] so hungry
[doge] wow

by huahaiy on 2024-12-16 . May have evaluation errors.

clojure.core/future¶

Examples¶

See also¶

`clojure.core/future`¶