promesa.exec — funcool/promesa 11.0.678

Executors & Schedulers facilities.

*default-executor* clj/s

*default-scheduler* clj/s

->ScheduledTask clj/s

cached-executor clj

(cached-executor &
                 {:keys [max-size factory keepalive]
                  :or {keepalive 60000 max-size Integer/MAX_VALUE}})

A cached thread executor pool constructor.

compile-if-virtual clj macro

(compile-if-virtual then else)

compile-when-virtual clj macro

(compile-when-virtual body)

configure-default-executor! clj

(configure-default-executor! & params)

current-thread clj

(current-thread)

Return the current thread.

current-thread-executor clj/s

(current-thread-executor)

Creates an executor instance that run tasks in the same thread.

default-current-thread-executor clj/s

Default Executor instance that runs the task in the same thread.

default-executor clj/s

Default executor instance, ForkJoinPool/commonPool in JVM, MicrotaskExecutor on JS.

default-scheduler clj/s

Default scheduled executor instance.

exec! clj/s

(exec! f)

(exec! executor f)

Run the task in the provided executor, returns nil. Analogous to the (.execute executor f). Fire and forget.

executor? clj/s

(executor? o)

Returns true if o is an instane of Executor or satisfies IExecutor protocol.

fixed-executor clj

(fixed-executor & {:keys [parallelism factory]})

A fixed thread executor pool constructor.

fn->thread clj

(fn->thread f
            &
            {:keys [daemon start priority name]
             :or {daemon true start true priority Thread/NORM_PRIORITY}})

forkjoin-executor clj

(forkjoin-executor &
                   {:keys [factory async parallelism keepalive core-size
                           max-size]
                    :or {max-size 32767 async true keepalive 60000}})

forkjoin-thread-factory clj

(forkjoin-thread-factory &
                         {:keys [name daemon]
                          :or {name "promesa/forkjoin/%s" daemon true}})

get-available-processors clj

(get-available-processors)

get-name clj

(get-name)

(get-name thread)

Retrieve thread name

get-thread-id clj

(get-thread-id)

(get-thread-id thread)

Retrieves the thread ID.

interrupt! clj

(interrupt!)

(interrupt! thread)

Interrupt a thread.

interrupted? clj

(interrupted?)

(interrupted? thread)

Check if the thread has the interrupted flag set.

There are two special cases:

Using the :current keyword as argument will check the interrupted flag on the current thread.

Using the arity 0 (passing no arguments), then the current thread will be checked and WARNING the interrupted flag reset to false.

microtask-executor cljs

(microtask-executor)

An IExecutor that schedules tasks to be executed in the MicrotasksQueue.

pmap clj

(pmap f coll)

(pmap f coll & colls)

Analogous to the clojure.core/pmap with the excetion that it allows use a custom executor (binded to default-executor var) The default clojure chunk size (32) is used for evaluation and the real parallelism is determined by the provided executor.

EXPERIMENTAL API: This function should be considered EXPERIMENTAL and may be changed or removed in future versions until this notification is removed.

run! clj/s

(run! f)

(run! executor f)

Run the task in the provided executor.

schedule! clj/s

(schedule! ms f)

(schedule! scheduler ms f)

Schedule a callable to be executed after the ms delay is reached.

In JVM it uses a scheduled executor service and in JS it uses the setTimeout function.

scheduled-executor clj/s

(scheduled-executor & {:keys [parallelism factory] :or {parallelism 1}})

A scheduled thread pool constructor. A ScheduledExecutor (IScheduler in CLJS) instance allows execute asynchronous tasks some time later.

set-name! clj

(set-name! name)

(set-name! thread name)

Rename thread.

shutdown! clj

(shutdown! executor)

Shutdowns the executor service.

shutdown-now! clj

(shutdown-now! executor)

Shutdowns and interrupts the executor service.

shutdown? clj

(shutdown? executor)

Check if execitor is in shutdown state.

single-executor clj

(single-executor & {:keys [factory]})

A single thread executor pool constructor.

sleep clj

(sleep ms)

Turn the current thread to sleep accept a number of milliseconds or Duration instance.

submit! clj/s

(submit! f)

(submit! executor f)

Submit a task to be executed in a provided executor and return a promise that will be completed with the return value of a task.

A task is a plain clojure function.

thread clj macro

(thread opts & body)

A low-level, not-pooled thread constructor, it accepts an optional map as first argument and the body. The options map is interepreted as options if a literal map is provided. The available options are: :name, :priority, :daemon and :virtual. The :virtual option is ignored if you are using a JVM that has no support for Virtual Threads.

thread-call clj

(thread-call f & {:as opts})

Advanced version of p/thread-call that creates and starts a thread configured with opts. No executor service is used, this will start a plain unpooled thread.

thread-factory clj/s≠

clj

(thread-factory
  &
  {:keys [name daemon priority]
   :or {daemon true priority Thread/NORM_PRIORITY name "promesa/thread/%s"}})

Returns an instance of promesa default thread factory.

cljs

thread-factory? clj

(thread-factory? o)

Checks if o is an instance of ThreadFactory

thread-id clj deprecated

(thread-id)

(thread-id thread)

Retrieves the thread ID.

thread? clj

(thread? t)

Check if provided object is a thread instance.

throw-uncaught! clj

(throw-uncaught! cause)

Throw an exception to the current uncaught exception handler.

virtual-threads-available? clj/s

Var that indicates the availability of virtual threads.

vthread-supported? clj/s deprecated

backward compatibility alias for virtual-threads-available?

with-dispatch clj/s macro

(with-dispatch executor & body)

Helper macro for dispatch execution of the body to an executor service. The returned promise is not cancellable (the body will be executed independently of the cancellation).

with-dispatch! clj/s macro

(with-dispatch! executor & body)

Blocking version of with-dispatch. Useful when you want to dispatch a blocking operation to a separated thread and join current thread waiting for result; effective when current thread is virtual thread.

with-executor clj/s macro

(with-executor executor & body)

Binds the default-executor var with the provided executor, executes the macro body. It also can optionally shutdown or shutdown and interrupt on termination if you provide ^:shutdown and ^:interrupt metadata.

EXPERIMENTAL API: This function should be considered EXPERIMENTAL and may be changed or removed in future versions until this notification is removed.

work-stealing-executor clj

(work-stealing-executor & params)

An alias for the forkjoin-executor.