Public

Performs the given task, returning its result upon completion. If the
computation encounters an unch

invoke

Creates a ForkJoinPool with the given parameters.

<init>

Arranges for (asynchronous) execution of the given task.

execute

Tries to create and start a worker; minimally rolls back counts on failure.

addWorker

If there is a security manager, makes sure caller has permission to modify
threads.

checkPermission

Final callback from terminating worker. Removes record of worker from array, and
adjusts counts. If 

deregisterWorker

Returns the targeted parallelism level of this pool.

getParallelism

Returns the number of worker threads that have started but not yet terminated.
The result returned b

getPoolSize

If inactivating worker w has caused pool to become quiescent, check for pool
termination, and wait f

idleAwaitWork

Returns the approximate (non-atomic) number of idle threads per active thread.

idlePerActive

Returns true if all tasks have completed following shut down.

isTerminated

Blocks in accord with the given blocker. If the current thread is a
ForkJoinWorkerThread, this metho

managedBlock

Callback from ForkJoinWorkerThread constructor to assign a public name

nextWorkerName

Callback from ForkJoinWorkerThread constructor to determine its poolIndex and
record in workers arra

registerWorker

Scans for and, if found, executes one task. Scans start at a random index of
workers array, and rand

scan

signalWork

Possibly initiates and/or completes termination.

tryTerminate

Directly increment or decrement active count without queuing. This method is
used to transiently ass

addActiveCount

Increment or decrement quiescerCount. Needed only to prevent triggering shutdown
if a worker is tran

addQuiescerCount

Enqueues the given task in the submissionQueue. Same idea as
ForkJoinWorkerThread.pushTask except fo

addSubmission

ForkJoinPool

Updating database using SQL prepared statement

Provides access to system-related information and resources including standard
input and output. Ena

java.lang.System

An immutable arbitrary-precision signed decimal.A value is represented by an
arbitrary-precision "un

java.math.BigDecimal

 ResourceBundle is an abstract class which is the superclass of classes which
provide Locale-specifi

java.util.ResourceBundle

An Executor that provides methods to manage termination and methods that can
produce a Future for tr

java.util.concurrent.ExecutorService

Patterns are compiled regular expressions. In many cases, convenience methods
such as String#matches

java.util.regex.Pattern

javax.swing.JOptionPane

getResourceAsStream

getExternalFilesDir

getApplicationContext

/**
     * Tries to activate or create a worker if too few are active.
     */

/**
     * Tries to decrement active count (sometimes implicitly) and
     * possibly release or create a compensating worker in preparation
     * for blocking. Fails on contention or termination. Otherwise,
     * adds a new thread if no idle workers are available and either
     * pool would become completely starved or: (at least half
     * starved, and fewer than 50% spares exist, and there is at least
     * one task apparently available). Even though the availability
     * check requires a full scan, it is worthwhile in reducing false
     * alarms.
     *
     * @param task if non-null, a task being waited for
     * @param blocker if non-null, a blocker being waited for
     * @return true if the caller can block, else should recheck and retry
     */

// in compensation range and tasks available

/**
     * Wakes up or creates a worker.
     */

/*
         * The while condition is true if: (there is are too few total
         * workers OR there is at least one waiter) AND (there are too
         * few active workers OR the pool is terminating).  The value
         * of e distinguishes the remaining cases: zero (no waiters)
         * for create, negative if terminating (in which case do
         * nothing), else release a waiter. The secondary checks for
         * release (non-null array etc) can fail if the pool begins
         * terminating after the test, and don't impose any added cost
         * because JVMs must perform null and bounds checks anyway.
         */

/**
     * Tries to increment blockedCount, decrement active count
     * (sometimes implicitly) and possibly release or create a
     * compensating worker in preparation for blocking. Fails
     * on contention or termination.
     *
     * @return true if the caller can block, else should recheck and retry
     */

// try to back out on any failure and let caller retry

How to use addWorkermethodin jsr166y.ForkJoinPool

Best Java code snippets using jsr166y.ForkJoinPool.addWorker (Showing top 4 results out of 315)

How to use
addWorker
method
in
jsr166y.ForkJoinPool