Clojure Q&A - Recent questions tagged future

How to force a timeout?

Tue, 12 Dec 2023 13:56:49 +0000

(defn tid []                                                        
  [(.getName (Thread/currentThread))                                                        
   (.getId (Thread/currentThread))])

   (defn atomize                                                   
  [f data]                                                                                  
  (let [atomix (atom [])                                                                    
        pool (Executors/newFixedThreadPool 12)                                              
        tasks (map                                                                          
               (fn [datum]                                                                  
                 (fn []                                                                     
                   (swap! atomix conj [(f datum) (tid)])))                                  
               data)]                                                                       
    (doseq [future (.invokeAll pool tasks)]                                                 
      (.get future  10 TimeUnit/MILLISECONDS ))                                             
    (.shutdown pool)                                                                        
    @atomix))




I can't figure out where to place a `sleep` to force a timeout.

Future doesn't stop running

Fri, 03 Feb 2023 15:32:19 +0000

(defn get-result-from-first-engine
"Performs search on Powells and Cultura and returns the results
which comes first"
[query]
(let [result (promise)]
    (doseq [engine ["powells" "cultura"]]
        (future (if-let [engine-result (search query engine)]
            (deliver result engine-result)
        ))
    )
    (println "First result: " (deref result 2000 "timed out"))
))

(defn -main
    [& args]

    (time (do
        (println (search "clojure" "powells"))
        (println (search "clojure" "cultura"))
    ))

    (time (get-result-from-first-engine "clojure"))
)

This code is part of my solution to the first exercise from chapter 9 of "Clojure for the Brave and True". I want to perform the two requests in parallel and get the response of the one who process first.

Two weird things are happening:

The time from the parallel is WAY lower than the sequential one, written in main. Result example below. The time difference is so discrepant, that i guess if clojure caches it someway. I didn't use memoize or anything like that.
The main doesn't stop running. It holds like if it was waiting for an input or processing something. My theory is that the future doesn't stop running, but i don't know why

Time difference between parallel and sequential:

https://www.powells.com/book/clojure-cookbook-9781449366179
https://www3.livrariacultura.com.br/clojure-94991222/p
"Elapsed time: 2185.2716 msecs"
First result:  https://www3.livrariacultura.com.br/clojure-94991222/p
"Elapsed time: 63.5558 msecs"

Thanks for the help in advance

Could realized? support Java futures?

Sat, 28 May 2022 07:16:15 +0000

I'm running into a situation where I would need to mix CompletableFutures in with Clojure futures/delays/etc. Unfortunately, IPending is an interface, which can't be extended to Java core classes.

For IDeref and IBlockingDeref, it's not a problem working with Java Futures, because the deref fn supports them.

Couldn't the same be done with the realized? fn? Currently, it only works with IPending. It would be ideal if it matched the deref behavior and called .isDone() when given a java.util.concurrent.Future.