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] |
Same as
ThreadPoolExecutor.await_termination .
|
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] |
Same as
ThreadPoolExecutor.get_active_count .
|
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] |
Same as
ThreadPoolExecutor.get_pool_size .
|
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] |
Same as
ThreadPoolExecutor.get_task_count .
|
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] |
Same as
ThreadPoolExecutor.invoke_all .
|
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] |
Same as
ThreadPoolExecutor.invoke_all_time .
|
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] |
Same as
ThreadPoolExecutor.invoke_any .
|
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] |
Same as
ThreadPoolExecutor.invoke_any_time .
|
is_alive [Thread] |
Tests whether the thread has started and not terminated.
|
is_broken [CyclicBarrier] |
Tests whether the barrier is broken.
|
is_cancelled [ScheduledFuture] |
Same as
Future.is_cancelled .
|
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] |
Same as
ThreadPoolExecutor.is_shutdown .
|
is_shutdown [ForkJoinPool] |
Tests whether the pool has been shutdown.
|
is_terminated [ThreadPoolExecutor] |
Tests whether the pool has been shutdown.
|
is_terminated [ScheduledThreadPoolExecutor] |
Same as
ThreadPoolExecutor.is_terminated .
|
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] |
Same as
ThreadPoolExecutor.is_terminating .
|
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] |
Same as
ThreadPoolExecutor.shutdown .
|
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] |
Same as
ThreadPoolExecutor.shutdown_now .
|
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] |
Same as
ThreadPoolExecutor.submit .
|
submit [ExecutorCompletionService] |
Same as
ThreadPoolExecutor.submit .
|
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.
|