Index of values


A
acquire [Semaphore]
acquire s p acquires p permits from semaphore s, blocking until they are available.
acquire_uninterruptibly [Semaphore]
acquire_uninterruptibly s p is similar to acquire s p, except that waiting thread cannot be interrupted.
active_count [ThreadGroup]
Returns the number of active threads in this group (including children groups).
active_group_count [ThreadGroup]
Returns the number of active groups in this group (including children groups).
add_and_get [AtomicInt64Array]
add_and_get a i d atomically adds d to the value at index i, and returns the new value.
add_and_get [AtomicInt64]
add_and_get a d atomically adds d to the current value, and returns the new value.
add_and_get [AtomicInt32Array]
add_and_get a i d atomically adds d to the value at index i, and returns the new value.
add_and_get [AtomicInt32]
add_and_get a d atomically adds d to the current value, and returns the new value.
append [ParallelArray.S]
append [ParallelArray]
Synonym for Array.append.
arrive [Phaser]
Records that a party has arrived to the phaser without waiting for others, returns the phase number (negative if the phaser is terminated).
arrive_and_await_advance [Phaser]
Records that a party has arrived to the phaser and waits for others, returns the phase number (negative if the phaser is terminated).
arrive_and_deregister [Phaser]
Records that a party has arrived to the phaser without waiting for others, deregisters a party, returns the phase number (negative if the phaser is terminated).
attempt_mark [AtomicMarkableReference]
attempt_mark a e m sets the mark to m if the current value is e.
attempt_stamp [AtomicStampedReference]
attempt_stamp a e s sets the stamp to s if the current value is e.
available_permits [Semaphore]
Returns the number of available permits for the semaphore.
available_processors [Runtime]
Returns the number of (logical) available processors.
await [CyclicBarrier]
Waits until all threads have reached the barrier.
await [CountDownLatch]
Waits until the coutdown reaches zero, without countingdown.
await [Condition]
Waits until either the condition is signal, or the current thread is interrupted.
await_advance [Phaser]
Waits for the phase number of the phaser to reach the passed value.
await_advance_interruptibly [Phaser]
Similar to await_advance except that the thread can be interrupted.
await_advance_interruptibly_time [Phaser]
await_advance_interruptibly_time p pn t u is similar to await_advance_interruptibly p pn, except that the current thread will at most wait for t (time value whose unit is u).
await_nanos [Condition]
await_nanos c n is similar to await c, except that the current thread will at most wait for n nanoseconds.
await_termination [ThreadPoolExecutor]
Waits for pool termination, waiting at most wait for t (time value whose unit is u).
await_termination [ScheduledThreadPoolExecutor]
await_termination [ForkJoinPool]
Waits for pool termination, waiting at most wait for t (time value whose unit is u).
await_time [CyclicBarrier]
await_time b t u is similar to await b, except that the current thread will at most wait for t (time value whose unit is u).
await_time [CountDownLatch]
await_time c t u is similar to await c, except that the current thread will at most wait for t (time value whose unit is u).
await_time [Condition]
await_time c t u is similar to await c, except that the current thread will at most wait for t (time value whose unit is u).
await_uninterruptibly [Condition]
Similar to await except that the thread cannot be interrupted.

B
blit [ParallelArray.S]
blit [ParallelArray]
Synonym for Array.blit.
bulk_register [Phaser]
bulk_register p n adds n unarrived parties to phaser p.

C
cancel [ScheduledFuture]
Same as Future.cancel.
cancel [Future]
cancel f i attemps to cancel future f, i indicating whether to interrupt the computation if already started.
chunk_size [ParallelArray.OptionalParameters]
The size of chunks for parallel computations.
combine [MapReduce.Computation]
combine operation, turning two values into one for a given key.
compare_and_set [AtomicStampedReference]
compare_and_set a er ur es us atomically sets the value of a to ur and stamp to us if the current value is er and the current stamp is es.
compare_and_set [AtomicReferenceArray]
compare_and_set a i e u atomically sets the value of a at index i to u if the current value is e.
compare_and_set [AtomicReference]
compare_and_set a e u atomically sets the value of a to u if the current value is e.
compare_and_set [AtomicMarkableReference]
compare_and_set a er ur em um atomically sets the value of a to ur and mark to um if the current value is er and the current mark is em.
compare_and_set [AtomicInt64Array]
compare_and_set a i e u atomically sets the value of a at index i to u if the current value is e.
compare_and_set [AtomicInt64]
compare_and_set a e u atomically sets the value of a to u if the current value is e.
compare_and_set [AtomicInt32Array]
compare_and_set a i e u atomically sets the value of a at index i to u if the current value is e.
compare_and_set [AtomicInt32]
compare_and_set a e u atomically sets the value of a to u if the current value is e.
compare_and_set [AtomicBool]
compare_and_set a e u atomically sets the value of a to u if the current value is e.
compare_keys [MapReduce.Computation]
Ordering over keys.
compute [MapReduce.S]
Iterates over the passed stream using pool threads to execute map operations over the various input values, and applies combine operation over values having identical keys as soon as they are available.
concat [ParallelArray.S]
concat [ParallelArray]
Synonym for Array.concat.
convert [TimeUnit]
convert f t x converts the value x from unit f to unit t.
copy [ParallelArray.S]
copy [ParallelArray]
Synonym for Array.copy.
count_down [CountDownLatch]
Decrements the count, and then waits for the countdown to reach zero.
create [ParallelArray.S]
create [ParallelArray]
Synonym for Array.create.
create_matrix [ParallelArray.S]
create_matrix [ParallelArray]
Synonym for Array.create_matrix.
current_thread [Thread]
Returns the thread that is currently executing.
current_time_millis [Runtime]
Returns the current time in milliseconds.

D
decrement_and_get [AtomicInt64Array]
Atomically decrements the value at passed index, and returns the new value.
decrement_and_get [AtomicInt64]
Atomically decrements the current value, and returns the new value.
decrement_and_get [AtomicInt32Array]
Atomically decrements the value at passed index, and returns the new value.
decrement_and_get [AtomicInt32]
Atomically decrements the current value, and returns the new value.
default_pool [ParallelArray]
The default pool used for parallel computations, initialized with a size of Runtime.available_processors.
destroy [ThreadGroup]
Destroys the passed group and all its children groups.
drain_permits [Semaphore]
Acquires and returns all available permits from the semaphore, returning immediately.

E
exchange [Exchanger]
Waits for another thread to arrive at the same exchange point, and then swaps the values provided by the two threads.
exchange_time [Exchanger]
exchange_time e x t u is similar to exchange e x, except that the current thread will at most wait for t (time value whose unit is u).
exists [ParallelArray.S]
exists [ParallelArray]
exists ~pool ~chunk_size f a returns true iff there is an element e of a such that f e = true.

F
fast_sort [ParallelArray.S]
fast_sort [ParallelArray]
Synonym for ParallelArray.sort.
fill [ParallelArray.S]
fill [ParallelArray]
Synonym for Array.fill.
find [ParallelArray.S]
find [ParallelArray]
find ~pool ~chunk_size f a returns an element e of a such that f e = true, raising Not_found if there is no such element in a.
find_all [ParallelArray.S]
find_all [ParallelArray]
find_all ~pool ~chunk_size f a returns all the elements of a that return true when applied to f, preserving the order of the elements in a.
find_index [ParallelArray.S]
find_index [ParallelArray]
Similar to find, except that the index is returned.
fold_left [ParallelArray.S]
fold_left [ParallelArray]
Similar to Array.fold_left, except that computations are done in parallel; pool indicates the thread pool to use (defaulting to default_pool), while chunk_size indicates the size of each chunk to be allocated to a thread.
fold_right [ParallelArray.S]
fold_right [ParallelArray]
Similar to Array.fold_right, except that computations are done in parallel; pool indicates the thread pool to use (defaulting to default_pool), while chunk_size indicates the size of each chunk to be allocated to a thread.
for_all [ParallelArray.S]
for_all [ParallelArray]
for_all ~pool ~chunk_size f a returns true iff there is no element e of a such that f e = false.
force_termination [Phaser]
Forces termination of the phaser, includind children phasers.
free_memory [Runtime]
Returns the amount of free memory in the JVM (in bytes).

G
get [ThreadLocal]
Returns the value of the thread-local variable for the current thread.
get [ScheduledFuture]
Same as Future.get.
get [ParallelArray.S]
get [ParallelArray]
Synonym for Array.get.
get [Future]
Waits for the computation to complete, and returns its result.
get [AtomicStampedReference]
Returns the current value and stamp.
get [AtomicReferenceArray]
Returns the value at passed index.
get [AtomicReference]
Returns the current value.
get [AtomicMarkableReference]
Returns the current value and mark.
get [AtomicInt64Array]
Returns the value at passed index.
get [AtomicInt64]
Returns the current value.
get [AtomicInt32Array]
Returns the value at passed index.
get [AtomicInt32]
Returns the current value.
get [AtomicBool]
Returns the current value.
get_active_count [ThreadPoolExecutor]
Returns an estimate of the number of active threads in the pool.
get_active_count [ScheduledThreadPoolExecutor]
get_active_thread_count [ForkJoinPool]
Returns an estimate of the number of active threads in the pool.
get_and_add [AtomicInt64Array]
get_and_add a i d atomically adds d to the value at index i, and returns the previous value.
get_and_add [AtomicInt64]
get_and_add a d atomically adds d to the current value, and returns the previous value.
get_and_add [AtomicInt32Array]
get_and_add a i d atomically adds d to the value at index i, and returns the previous value.
get_and_add [AtomicInt32]
get_and_add a d atomically adds d to the current value, and returns the previous value.
get_and_decrement [AtomicInt64Array]
Atomically decrements the value at passed index, and returns the previous value.
get_and_decrement [AtomicInt64]
Atomically decrements the current value, and returns the previous value.
get_and_decrement [AtomicInt32Array]
Atomically decrements the value at passed index, and returns the previous value.
get_and_decrement [AtomicInt32]
Atomically decrements the current value, and returns the previous value.
get_and_increment [AtomicInt64Array]
Atomically increments the value at passed index, and returns the previous value.
get_and_increment [AtomicInt64]
Atomically increments the current value, and returns the previous value.
get_and_increment [AtomicInt32Array]
Atomically increments the value at passed index, and returns the previous value.
get_and_increment [AtomicInt32]
Atomically increments the current value, and returns the previous value.
get_and_set [AtomicReferenceArray]
get_and_set a i x atomically sets the value of a at index i to x, and returns the previous value.
get_and_set [AtomicReference]
get_and_set a x atomically sets the value of a to x, and returns the previous value.
get_and_set [AtomicInt64Array]
get_and_set a i x atomically sets the value of a at index i to x, and returns the previous value.
get_and_set [AtomicInt64]
get_and_set a x atomically sets the value of a to x, and returns the previous value.
get_and_set [AtomicInt32Array]
get_and_set a i x atomically sets the value of a at index i to x, and returns the previous value.
get_and_set [AtomicInt32]
get_and_set a x atomically sets the value of a to x, and returns the previous value.
get_and_set [AtomicBool]
get_and_set a x atomically sets the value of a to x, and returns the previous value.
get_arrived_parties [Phaser]
Returns the number of registered parties that have arrived to the phaser.
get_async_mode [ForkJoinPool]
Returns the asynchronous mode of the pool.
get_completed_task_count [ThreadPoolExecutor]
Returns an estimate of the number of completed computations in the pool.
get_completed_task_count [ScheduledThreadPoolExecutor]
get_continue_existing_periodic_tasks_after_shutdown_policy [ScheduledThreadPoolExecutor]
Tests whether periodic tasks should continue execution after shutdown.
get_core_pool_size [ThreadPoolExecutor]
Returns the core size of the pool.
get_core_pool_size [ScheduledThreadPoolExecutor]
get_count [CountDownLatch]
Returns the current count.
get_delay [ScheduledFuture]
Returns the remaining delay for the computation, in the passed time unit.
get_execute_existing_delayed_tasks_after_shutdown_policy [ScheduledThreadPoolExecutor]
Tests whether delayed tasks should continue execution after shutdown.
get_id [Thread]
Returns the thread identifier.
get_keep_alive_time [ThreadPoolExecutor]
Returns the keep alive time for thread outside of the core.
get_keep_alive_time [ScheduledThreadPoolExecutor]
get_largest_pool_size [ThreadPoolExecutor]
Returns the largest size reached by the pool.
get_largest_pool_size [ScheduledThreadPoolExecutor]
get_max_priority [ThreadGroup]
Returns the maximum priority of the group.
get_maximum_pool_size [ThreadPoolExecutor]
Returns the maximum size of the pool.
get_maximum_pool_size [ScheduledThreadPoolExecutor]
get_name [ThreadGroup]
Returns the name of the group.
get_name [Thread]
Returns the name of the thread.
get_number_waiting [CyclicBarrier]
Returns the number of threads currently waiting on the barrier.
get_parallelism [ForkJoinPool]
Returns the parallelism of the pool.
get_parent [ThreadGroup]
Returns the parent of the group, None if no such group exists.
get_parent [Phaser]
Returns the parent of the phaser.
get_parties [CyclicBarrier]
Returns the number of threads to be waited on the barrier.
get_phase [Phaser]
Returns the phase number.
get_pool_size [ThreadPoolExecutor]
Returns an estimate of the current pool size.
get_pool_size [ScheduledThreadPoolExecutor]
get_pool_size [ForkJoinPool]
Returns the number of threads that have started and not terminated in the pool.
get_priority [Thread]
Returns the priority of the thread.
get_queue_length [Semaphore]
Returns an estimate of the number of threads waiting on the semaphore to acquire permits.
get_queued_submission_count [ForkJoinPool]
Returns an estimate of the number of tasks submitted (but unstarted) to the pool.
get_queued_task_count [ForkJoinPool]
Returns an estimate of the number of tasks currently queued in the pool.
get_reference [AtomicStampedReference]
Returns the current value.
get_reference [AtomicMarkableReference]
Returns the current value.
get_registered_parties [Phaser]
Returns the number of registered parties.
get_rejected_execution_handler [ThreadPoolExecutor]
Returns the policy for blocked computations.
get_rejected_execution_handler [ScheduledThreadPoolExecutor]
get_remove_on_cancel_policy [ScheduledThreadPoolExecutor]
Tests whether tasks should be removed when cancelled.
get_root [Phaser]
Returns the root that can be reached from the phaser by recursively visiting parents.
get_running_thread_count [ForkJoinPool]
Returns an estimate of the number of threads in the pool.
get_stamp [AtomicStampedReference]
Returns the current stamp.
get_state [Thread]
Returns the state of the thread.
get_steal_count [ForkJoinPool]
Returns an estimate of the number of tasks stolen from one thread by another one in the pool.
get_task_count [ThreadPoolExecutor]
Returns an estimate of number of task that have been submitted for execution.
get_task_count [ScheduledThreadPoolExecutor]
get_thread_group [Thread]
Returns the group of the thread, None if the thread has terminated its execution.
get_time [ScheduledFuture]
Same as Future.get_time.
get_time [Future]
get_time f t u is similar to get f, except that the current thread will at most wait for t (time value whose unit is u).
get_unarrived_parties [Phaser]
Returns the number of registered parties that have not yet arrived to the phaser.

H
has_queued_submissions [ForkJoinPool]
Tests whether there are submitted but unstarted tasks in the pool.
has_queued_threads [Semaphore]
Tests whether there are threads waiting on the semaphore to acquire permits.

I
increment_and_get [AtomicInt64Array]
Atomically increments the value at passed index, and returns the new value.
increment_and_get [AtomicInt64]
Atomically increments the current value, and returns the new value.
increment_and_get [AtomicInt32Array]
Atomically increments the value at passed index, and returns the new value.
increment_and_get [AtomicInt32]
Atomically increments the current value, and returns the new value.
init [ParallelArray.S]
init [ParallelArray]
Similar to Array.init, except that computations are done in parallel; pool indicates the thread pool to use (defaulting to default_pool), while chunk_size indicates the size of each chunk to be allocated to a thread.
interrupt [ThreadGroup]
Interrupts all thread in the group (including children groups).
interrupt [Thread]
Interrupts the thread.
interrupted [Thread]
Tests whether the current thread has been interrupted, and sets its interrupted status to false.
invoke_all [ThreadPoolExecutor]
invoke_all p l submits all functions from l to pool p, and then waits for the completion of all functions.
invoke_all [ScheduledThreadPoolExecutor]
invoke_all_time [ThreadPoolExecutor]
invoke_all_time p l t u is similar to invoke_all p l, except that the current thread will at most wait for t (time value whose unit is u).
invoke_all_time [ScheduledThreadPoolExecutor]
invoke_any [ThreadPoolExecutor]
invoke_any p l submits all function from l to pool p, and then waits for the completion of a function.
invoke_any [ScheduledThreadPoolExecutor]
invoke_any_time [ThreadPoolExecutor]
invoke_any_time p l t u is similar to invoke_any p l, except that the current thread will at most wait for t (time value whose unit is u).
invoke_any_time [ScheduledThreadPoolExecutor]
is_alive [Thread]
Tests whether the thread has started and not terminated.
is_broken [CyclicBarrier]
Tests whether the barrier is broken.
is_cancelled [ScheduledFuture]
is_cancelled [Future]
Tests whether the task was cancelled before completion.
is_daemon [ThreadGroup]
Tests whether the group is a daemon one.
is_daemon [Thread]
Tests whether the thread is a daemon one.
is_destroyed [ThreadGroup]
Tests whether the group has been destroyed.
is_done [ScheduledFuture]
Same as Future.is_done.
is_done [Future]
Tests whether the computation is completed.
is_fair [Semaphore]
Tests whether the semaphore uses a fair policy.
is_interrupted [Thread]
Tests whether the thread has been interrupted.
is_marked [AtomicMarkableReference]
Returns the current mark.
is_quiescent [ForkJoinPool]
Tests whether all threads in the pool are idle.
is_shutdown [ThreadPoolExecutor]
Tests whether the pool has been shutdown.
is_shutdown [ScheduledThreadPoolExecutor]
is_shutdown [ForkJoinPool]
Tests whether the pool has been shutdown.
is_terminated [ThreadPoolExecutor]
Tests whether the pool has been shutdown.
is_terminated [ScheduledThreadPoolExecutor]
is_terminated [Phaser]
Tests whether the phaser has been terminated.
is_terminated [ForkJoinPool]
Tests whether shutdown is completed (including all tasks).
is_terminating [ThreadPoolExecutor]
Tests whether the pool is in the process shutdowning.
is_terminating [ScheduledThreadPoolExecutor]
is_terminating [ForkJoinPool]
Tests whether the pool is in the process shutdowning.
iter [ParallelArray.S]
iter [ParallelArray]
Similar to Array.iter, except that computations are done in parallel; pool indicates the thread pool to use (defaulting to default_pool), while chunk_size indicates the size of each chunk to be allocated to a thread.
iteri [ParallelArray.S]
iteri [ParallelArray]
Similar to Array.iteri, except that computations are done in parallel; pool indicates the thread pool to use (defaulting to default_pool), while chunk_size indicates the size of each chunk to be allocated to a thread.

J
join [Thread]
Waits for the termination of the passed thread.
join_time [Thread]
join_time t m is similar to join t, except that the current thread will at most wait for m milliseconds.
join_time_nanos [Thread]
join_time t m n is similar to join t, except that the current thread will at most wait for m milliseconds plus n nanoseconds.

L
lazy_set [AtomicReferenceArray]
lazy_set a i x eventually sets the value of a at index i to x.
lazy_set [AtomicReference]
lazy_set a x eventually sets the value of a to x.
lazy_set [AtomicInt64Array]
lazy_set a i x eventually sets the value of a at index i to x.
lazy_set [AtomicInt64]
lazy_set a x eventually sets the value of a to x.
lazy_set [AtomicInt32Array]
lazy_set a i x eventually sets the value of a at index i to x.
lazy_set [AtomicInt32]
lazy_set a x eventually sets the value of a to x.
lazy_set [AtomicBool]
lazy_set a x eventually sets the value of a to x.
length [ParallelArray.S]
length [ParallelArray]
Synonym for Array.length.
length [AtomicReferenceArray]
Returns the length of the array.
length [AtomicInt64Array]
Returns the length of the array.
length [AtomicInt32Array]
Returns the length of the array.
lock [Lock]
Acquires the lock.
lock_interruptibly [Lock]
Similar to lock, except that some other thread may interrupt the current thread while blocked.

M
make [ThreadPoolExecutor]
make cps mps kat u reh returns a new thread pool with: cps as its core pool size (number of threads kept in the pool, even if idle);, mps as its maximum pool size (maximum number of threads in the pool);, kat keep alive time (how long to keep alive idle threads not in the core);, u time unit for kat;, reh policy for blocked computations. Raises Invalid_argument if a size is negative.
make [ThreadLocal]
Returns a new thread-local variable whose initial value in each thread is the passed value.
make [ThreadGroup]
Returns a new group with optional parent, and name.
make [Thread]
make g n f x returns a new thread in group g with name n.
make [Semaphore]
make p f returns a new semaphore with p permits, f indicating whether a fair ordering policy is requested.
make [ScheduledThreadPoolExecutor]
make cps reh returns a new thread pool with: cps as its core pool size (number of threads kept in the pool, even if idle);, reh policy for blocked computations. Raises Invalid_argument if cps is negative.
make [Phaser]
make p n returns a new phaser with parent p, and number of parties n.
make [ParallelArray.S]
make [ParallelArray]
Synonym for Array.make.
make [ForkJoinPool]
make p a returns a new thread pool with parallelism p (target number of active threads in pool).
make [ExecutorCompletionService]
Returns a new completion service based on the passed thread pool.
make [Exchanger]
Returns a new exchanger.
make [CyclicBarrier]
make n returns a barrier waiting for n threads.
make [CountDownLatch]
make n returns a countdown latch waiting for n threads.
make [AtomicStampedReference]
Returns a new container holding the passed value, with the passed stamp.
make [AtomicReferenceArray]
Returns a new container holding an array of passed length.
make [AtomicReference]
Returns a new container holding the passed value.
make [AtomicMarkableReference]
Returns a new container holding the passed value, with the passed mark.
make [AtomicInt64Array]
Returns a new container holding an array of passed length.
make [AtomicInt64]
Returns a new container holding the passed value.
make [AtomicInt32Array]
Returns a new container holding an array of passed length.
make [AtomicInt32]
Returns a new container holding the passed value.
make [AtomicBool]
Returns a new container holding the passed value.
make_matrix [ParallelArray.S]
make_matrix [ParallelArray]
Synonym for Array.make_matrix.
make_reentrant [ReadWriteLock]
Returns a new read/write lock, whose read and write locks are reentrant, the parameter indicates whether a fair ordering policy is requested.
make_reentrant [Lock]
Returns a new reentrant lock, the parameter indicates whether a fair ordering policy is requested.
map [ParallelArray.S]
map [ParallelArray]
Similar to Array.map, except that computations are done in parallel; pool indicates the thread pool to use (defaulting to default_pool), while chunk_size indicates the size of each chunk to be allocated to a thread.
map [MapReduce.Computation]
map operation, turning an input value into a list of key/value couples.
mapi [ParallelArray.S]
mapi [ParallelArray]
Similar to Array.mapi, except that computations are done in parallel; pool indicates the thread pool to use (defaulting to default_pool), while chunk_size indicates the size of each chunk to be allocated to a thread.
max_memory [Runtime]
Returns the maximum amount of memory to be used by the JVM (in bytes).
max_priority [Thread]
The maximum priority for a thread.
mem [ParallelArray.S]
mem [ParallelArray]
mem ~pool ~chunk_size x a returns true iff there is an element e of a such that e = x.
memq [ParallelArray.S]
memq [ParallelArray]
memq ~pool ~chunk_size x a returns true iff there is an element e of a such that e == x.
min_priority [Thread]
The minimum priority for a thread.

N
nano_time [Runtime]
Similar to current_time_millis, with greater resolution.
new_condition [Lock]
Returns a new condition associated with the passed lock.
norm_priority [Thread]
The normal (i.

O
of_list [ParallelArray.S]
of_list [ParallelArray]
Synonym for Array.of_list.

P
parent_of [ThreadGroup]
parent_of p c tests whether p is an ancestor of c.
poll [ExecutorCompletionService]
Returns (and removes from the service) a completed task if any, or returns None.
poll_time [ExecutorCompletionService]
poll_time s t u is similar to pool s, except that the current thread will at most wait for t (time value whose unit is u).
pool [ParallelArray.OptionalParameters]
The pool to be used for parallel computations.

R
read_lock [ReadWriteLock]
Returns the read lock of the read/write lock.
reduce [MapReduce.Computation]
reduce operation, folding over all key/value couple in order to produce the final result.
ref [STM]
Builds a value of type ref, that can then only be accessed during a transaction.
register [Phaser]
Adds a new unarrived party to the phaser, and returns the current phase number
release [Semaphore]
release s p releases p permits from semaphore s.
remove [ThreadLocal]
Removes the value of the thread-local variable for the current thread.
reset [CyclicBarrier]
Resets the barrier to its original state.
run [STM]
run ~retries f executes the function f inside a newly-created transaction.
run_read_only [STM]
Akin to run, but with a smaller overhead due to the fact that the transaction is guaranteed to only read values.

S
schedule [ScheduledThreadPoolExecutor]
schedule p f x t u is similar to submit p f x, except that the evaluation of f x with start after t (time value whose unit is u).
schedule_at_fixed_rate [ScheduledThreadPoolExecutor]
schedule_at_fixed_rate p f x t d u is similar to schedule p f x t u, except that f x will be re-evaluated at t + d, t + 2 * d, etc.
schedule_with_fixed_delay [ScheduledThreadPoolExecutor]
schedule_with_fixed_delay p f x t d u is similar to schedule p f x t u, except that f x will be repeatedly re-evaluated, respecting a delay of d between the end of one execution and the beginning of the next one.
set [ThreadLocal]
Modifies the value of the thread-local variable for the current thread.
set [ParallelArray.S]
set [ParallelArray]
Synonym for Array.set.
set [AtomicStampedReference]
set a x s sets the value of a to x, and the stamp to s.
set [AtomicReferenceArray]
set a i x sets the value of a at index i to x.
set [AtomicReference]
set a x sets the value of a to x.
set [AtomicMarkableReference]
set a x m sets the value of a to x, and the mark to m.
set [AtomicInt64Array]
set a i x sets the value of a at index i to x.
set [AtomicInt64]
set a x sets the value of a to x.
set [AtomicInt32Array]
set a i x sets the value of a at index i to x.
set [AtomicInt32]
set a x sets the value of a to x.
set [AtomicBool]
set a x sets the value of a to x.
set_continue_existing_periodic_tasks_after_shutdown_policy [ScheduledThreadPoolExecutor]
Changes whether periodic tasks should continue execution after shutdown.
set_core_pool_size [ThreadPoolExecutor]
Changes the core size of the pool (number of threads kept in the pool, even if idle).
set_core_pool_size [ScheduledThreadPoolExecutor]
set_daemon [ThreadGroup]
Sets the daemon status of the group.
set_daemon [Thread]
Changes the daemon status of the thread.
set_execute_existing_delayed_tasks_after_shutdown_policy [ScheduledThreadPoolExecutor]
changes whether delayed tasks should continue execution after shutdown.
set_keep_alive_time [ThreadPoolExecutor]
Changes the keep alive time (how long to keep alive idle threads not in the core).
set_keep_alive_time [ScheduledThreadPoolExecutor]
set_max_priority [ThreadGroup]
Sets the maximum priority of the group.
set_maximum_pool_size [ThreadPoolExecutor]
Changes the maximum pool size (maximum number of threads in the pool).
set_maximum_pool_size [ScheduledThreadPoolExecutor]
set_name [Thread]
Changes the name of the thread.
set_priority [Thread]
Changes the priority of the thread.
set_rejected_execution_handler [ThreadPoolExecutor]
Changes the policy for blocked computations.
set_rejected_execution_handler [ScheduledThreadPoolExecutor]
set_remove_on_cancel_policy [ScheduledThreadPoolExecutor]
Changes whether tasks should be removed when cancelled.
shutdown [ThreadPoolExecutor]
Begins a shutdown, executing all submitted tasks, but refusing new tasks.
shutdown [ScheduledThreadPoolExecutor]
shutdown [ForkJoinPool]
Begins a shutdown, executing all submitted tasks, but refusing new tasks.
shutdown_now [ThreadPoolExecutor]
Begins a shhutdown by cancelling all submitted tasks, and cancelling running tasks.
shutdown_now [ScheduledThreadPoolExecutor]
shutdown_now [ParallelArray]
Shutdowns default_pool.
shutdown_now [ForkJoinPool]
Begins a shhutdown by cancelling all submitted tasks, and cancelling running tasks.
signal [Condition]
Signals the condition, unblocking one waiting thread.
signal_all [Condition]
Signals the condition, unblocking all waiting threads.
sleep [Thread]
sleep m waits for m milliseconds.
sleep_nanos [Thread]
sleep m n waits for m milliseconds plus n nanoseconds.
sort [ParallelArray.S]
sort [ParallelArray]
Similar to Array.sort, except that computations are done in parallel; pool indicates the thread pool to use (defaulting to default_pool), while chunk_size indicates the size of each chunk to be allocated to a thread.
split [ForkJoin]
split pool fork join f x computes f x by leveraging multiple threads from pool.
split_array [ForkJoin]
split_array pool fork join f x is similar to split pool fork join f x, except that the fork function can generate more than two sub-computations.
split_list [ForkJoin]
split_list pool fork join f x is similar to split pool fork join f x, except that the fork function can generate more than two sub-computations.
stable_sort [ParallelArray.S]
stable_sort [ParallelArray]
Synonym for ParallelArray.sort.
start [Thread]
Starts the execution of the thread.
sub [ParallelArray.S]
sub [ParallelArray]
Synonym for Array.sub.
submit [ThreadPoolExecutor]
submit p f x submits to p and returns a future computing f x.
submit [ScheduledThreadPoolExecutor]
submit [ExecutorCompletionService]

T
take [ExecutorCompletionService]
Waits for a task to complete, and returns it.
to_list [ParallelArray.S]
to_list [ParallelArray]
Synonym for Array.to_list.
total_memory [Runtime]
Returns the total amount of memory used by the JVM (in bytes).
try_acquire [Semaphore]
try_acquire s p is similar to acquire s p, except the function always returns immediately returning true if acquisition was successful.
try_acquire_time [Semaphore]
try_acquire_time s p t u is similar to try_acquire s p, except that the current thread will at most wait for t (time value whose unit is u).
try_lock [Lock]
Acquires the lock if available, returning true.
try_lock_time [Lock]
try_lock_time l t u is similar to lock_interruptibly l, except that the current thread will at most wait for t (time value whose unit is u).

U
unlock [Lock]
Releases the lock.
unsafe_get [ParallelArray.S]
unsafe_set [ParallelArray.S]

W
weak_compare_and_set [AtomicStampedReference]
Similar to compare_and_set, with a weak semantics: may be faster on some platforms, but does not provide ordering guarantees.
weak_compare_and_set [AtomicReferenceArray]
Similar to compare_and_set, with a weak semantics: may be faster on some platforms, but does not provide ordering guarantees.
weak_compare_and_set [AtomicReference]
Similar to compare_and_set, with a weak semantics: may be faster on some platforms, but does not provide ordering guarantees.
weak_compare_and_set [AtomicMarkableReference]
Similar to compare_and_set, with a weak semantics: may be faster on some platforms, but does not provide ordering guarantees.
weak_compare_and_set [AtomicInt64Array]
Similar to compare_and_set, with a weak semantics: may be faster on some platforms, but does not provide ordering guarantees.
weak_compare_and_set [AtomicInt64]
Similar to compare_and_set, with a weak semantics: may be faster on some platforms, but does not provide ordering guarantees.
weak_compare_and_set [AtomicInt32Array]
Similar to compare_and_set, with a weak semantics: may be faster on some platforms, but does not provide ordering guarantees.
weak_compare_and_set [AtomicInt32]
Similar to compare_and_set, with a weak semantics: may be faster on some platforms, but does not provide ordering guarantees.
weak_compare_and_set [AtomicBool]
Similar to compare_and_set, with a weak semantics: may be faster on some platforms, but does not provide ordering guarantees.
write_lock [ReadWriteLock]
Returns the write lock of the read/write lock.

Y
yield [Thread]
Indicates that the current thread wants to yield its use of a processor.