Promessas, futuros e operações assíncronas

Welcome! In this lesson, we'll explore asynchronous programming in Clojure. This is key for building responsive applications that don't freeze while waiting for long tasks.

Asynchronous tasks run in the 'background', allowing your main program to continue without interruption. When the background task finishes, it delivers its result.

Imagine fetching data from a slow server. A blocking operation would make your application wait until the data arrives. During this time, nothing else can happen.

A non-blocking operation starts the fetch but immediately returns control to your application. Your app can then do other things, and process the data once it's available.

Clojure provides the future macro to run a computation on a separate thread. This makes the computation asynchronous and non-blocking from the caller's perspective.

The future immediately returns a 'future' object, which is a placeholder for the eventual result.

Let's see future in action. We'll simulate a long-running task using Thread/sleep. Notice how the "Future started" message appears instantly.

To get the actual value from a future, you dereference it. You can use the @ reader macro or the deref function.

If the future's computation isn't finished yet, dereferencing will block the current thread until the result is ready.

While future runs a computation, a promise is a placeholder for a value that will be delivered later, usually by another thread or an external event.

Think of it as an empty box that someone else will fill. You can wait for the box to be filled by dereferencing it.

The deliver function is used to put a value into a promise. Once a promise is delivered, its value cannot be changed.

Dereferencing a promise works just like a future: it will block until a value is delivered.

future and promise often work together. A future might perform a complex calculation, and then deliver its result to a promise, which can then be picked up by another part of your application.

This pattern is useful for coordinating between different asynchronous tasks or threads.

When an exception occurs inside a future or before a promise is delivered, dereferencing the future/promise will re-throw that exception on the dereferencing thread.

This allows you to handle errors in your main thread, even if they originate from an asynchronous task.

Consider the following Clojure code snippet:

(let [f (future (Thread/sleep 1000) "Async Result")]
  (println "Started")
  (Thread/sleep 500)
  (println "Waiting...")
  (let [result @f]
    (println "Got:" result)))

What is the *minimum* total time before "Got: Async Result" is printed?

• Asynchronous programming allows tasks to run without blocking the main program flow.
• Clojure's future macro runs a computation on a separate thread, returning a placeholder immediately.
• The promise function creates a placeholder that can be delivered a value later, often from another thread or external source.
• Both future and promise are dereferenced (using @ or deref) to retrieve their values, blocking if the value isn't ready.
• Exceptions in async tasks are re-thrown when dereferenced.