How to sleep a thread in Clojure

A thread is referred to as the smallest unit of processing. The concept of threads in Clojure is the same as in any other programming language. Thread is used to implement concurrent programmingConcurrency generally refers to events or circumstances happening or existing simultaneously. in Clojure, which allows multiple computations to occur simultaneously.

Syntax

You can use the Thread/sleep function to sleep a thread in Clojure. The Thread/sleep function takes a single argument—the number of milliseconds to sleep.

(Thread/sleep 1000) ; sleep for 1 second

The above statement will cause the thread to sleep for one second. We can modify the time by changing the value.

Code example

Let’s look at an example of how to create a thread that sleeps for three seconds and prints a message:

;; defining a function 'my-thread-fn'
(defn my-thread-fn []
  ;; first print statement before sleeping the thread
  (println "Hello from my-thread")
  ;; sleeping this thread for 3 seconds
  (Thread/sleep 3000)
  ;; second print statement after sleeping the thread
  (println "Goodbye from my-thread"))
;; creating a Thread object using the function
(let [t (Thread. my-thread-fn)]
  ;; starting the thread using 'start'
  (.start t)
  ;; wait for the thread to complete using the 'join' method
  (.join t))
Sleeping a thread in Clojure

Note: Try changing the time for the thread to sleep to more than three seconds. You'll notice that the execution time changes when the output is displayed.

Code explanation

  • Lines 2–8: We define a function, my-thread-fn, using defn. This function prints two messages, one before the thread sleeps and the one after sleeping the thread for three seconds.

  • Line 11: We create a new Thread object using the my-thread-fn function.

  • Line 13: We start the thread using the start method.

  • Line 15: Wait for the thread to complete using the join method.

Overall, sleeping a thread can be a helpful tool for managing resource usage, introducing delays in program execution, and synchronizing the execution of multiple threads. However, it’s essential to use sleep judiciously, as excessive use of sleep can lead to performance problems and make it difficult to reason about program behavior.

Free Resources

Copyright ©2026 Educative, Inc. All rights reserved