promesa.exec — funcool/promesa 9.0.488

Executors & Schedulers facilities.

*default-executor* clj/s

*default-scheduler* clj/s

*thread-executor* clj/s

*vthread-executor* clj/s

cached-executor clj

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

A cached thread executor pool constructor.

cached-pool clj deprecated

(cached-pool)

(cached-pool opts)

A cached thread pool constructor.

concurrency-limiter clj

(concurrency-limiter
  &
  {:keys [executor concurrency queue-size on-run on-poll on-queue]
   :or
     {executor *default-executor* concurrency 1 queue-size Integer/MAX_VALUE}})

Create an instance of concurrencly limiter. EXPERIMENTAL

configure-default-executor! clj

(configure-default-executor! & params)

counter clj

default-forkjoin-thread-factory clj

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

default-thread-factory clj

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

executor? clj/s

(executor? o)

fixed-executor clj

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

A fixed thread executor pool constructor.

fixed-pool clj deprecated

(fixed-pool n)

(fixed-pool n opts)

A fixed thread pool constructor.

forkjoin-executor clj

(forkjoin-executor & {:keys [factory async? parallelism] :or {async? true}})

forkjoin-pool clj deprecated

(forkjoin-pool {:keys [factory async? parallelism] :or {async? true} :as opts})

noop clj/s

resolve-executor clj/s

(resolve-executor)

(resolve-executor executor)

resolve-scheduler clj/s

(resolve-scheduler)

(resolve-scheduler scheduler)

run! clj/s

(run! f)

(run! executor f)

Run the task in the provided executor.

same-thread-executor clj/s

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

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

A scheduled thread pool constructor.

scheduled-pool clj deprecated

(scheduled-pool)

(scheduled-pool n)

(scheduled-pool n opts)

A scheduled thread pool constructor.

single-executor clj

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

A single thread executor pool constructor.

single-pool clj deprecated

(single-pool)

(single-pool opts)

A single thread pool constructor.

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-factory? clj

(thread-factory? o)

vthreads-supported? clj/s

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).

work-stealing-executor clj

(work-stealing-executor & params)

An alias for the forkjoin-executor.

work-stealing-pool clj deprecated

(work-stealing-pool)

(work-stealing-pool n)

Creates a work-stealing thread pool.

wrap-bindings clj/s

(wrap-bindings f)