| Methods Summary |
|---|
| public long | averageWorkCompletionTime()This method returns the average elapsed time taken to complete a Work
item in milliseconds.
synchronized (lock) {
return (totalTimeTaken / processedCount);
}
|
| void | createWorkerThread()To be called from the workqueue to create worker threads when none
available.
synchronized (lock) {
final String name = getName() ;
if (boundedThreadPool) {
if (currentThreadCount < maxWorkerThreads) {
currentThreadCount++;
} else {
// REVIST - Need to create a thread to monitor the
// the state for deadlock i.e. all threads waiting for
// something which can be got from the item in the
// workqueue, but there is no thread available to
// process that work item - DEADLOCK !!
return;
}
} else {
currentThreadCount++;
}
// If we get here, we need to create a thread.
AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
// Thread creation needs to be in a doPrivileged block
// for two reasons:
// 1. The creation of a thread in a specific ThreadGroup
// is a privileged operation. Lack of a doPrivileged
// block here causes an AccessControlException
// (see bug 6268145).
// 2. We want to make sure that the permissions associated
// with this thread do NOT include the permissions of
// the current thread that is calling this method.
// This leads to problems in the app server where
// some threads in the ThreadPool randomly get
// bad permissions, leading to unpredictable
// permission errors.
WorkerThread thread = new WorkerThread(threadGroup, name);
// The thread must be set to a daemon thread so the
// VM can exit if the only threads left are PooledThreads
// or other daemons. We don't want to rely on the
// calling thread always being a daemon.
// Note that no exception is possible here since we
// are inside the doPrivileged block.
thread.setDaemon(true);
thread.start();
return null ;
}
}
) ;
}
|
| public int | currentNumberOfThreads()This method will return the total number of threads currently in the
threadpool. This method returns a value which is not synchronized.
synchronized (lock) {
return currentThreadCount;
}
|
| public long | currentProcessedCount()This method returns the number of Work items processed by the threadpool
synchronized (lock) {
return processedCount;
}
|
| public com.sun.corba.se.spi.orbutil.threadpool.WorkQueue | getAnyWorkQueue()
return workQueue;
|
| com.sun.corba.se.spi.monitoring.MonitoredObject | getMonitoredObject()
return threadpoolMonitoredObject;
|
| public java.lang.String | getName()
return name;
|
| private static synchronized int | getUniqueThreadId()
return ThreadPoolImpl.threadCounter++;
|
| public com.sun.corba.se.spi.orbutil.threadpool.WorkQueue | getWorkQueue(int queueId)
if (queueId != 0)
throw new NoSuchWorkQueueException();
return workQueue;
|
| public long | idleTimeoutForThreads()This method will return the time in milliseconds when idle
threads in the threadpool are removed.
return inactivityTimeout;
|
| private void | initializeMonitoring()
// Get root monitored object
MonitoredObject root = MonitoringFactories.getMonitoringManagerFactory().
createMonitoringManager(MonitoringConstants.DEFAULT_MONITORING_ROOT, null).
getRootMonitoredObject();
// Create the threadpool monitoring root
MonitoredObject threadPoolMonitoringObjectRoot = root.getChild(
MonitoringConstants.THREADPOOL_MONITORING_ROOT);
if (threadPoolMonitoringObjectRoot == null) {
threadPoolMonitoringObjectRoot = MonitoringFactories.
getMonitoredObjectFactory().createMonitoredObject(
MonitoringConstants.THREADPOOL_MONITORING_ROOT,
MonitoringConstants.THREADPOOL_MONITORING_ROOT_DESCRIPTION);
root.addChild(threadPoolMonitoringObjectRoot);
}
threadpoolMonitoredObject = MonitoringFactories.
getMonitoredObjectFactory().
createMonitoredObject(name,
MonitoringConstants.THREADPOOL_MONITORING_DESCRIPTION);
threadPoolMonitoringObjectRoot.addChild(threadpoolMonitoredObject);
LongMonitoredAttributeBase b1 = new
LongMonitoredAttributeBase(MonitoringConstants.THREADPOOL_CURRENT_NUMBER_OF_THREADS,
MonitoringConstants.THREADPOOL_CURRENT_NUMBER_OF_THREADS_DESCRIPTION) {
public Object getValue() {
return new Long(ThreadPoolImpl.this.currentNumberOfThreads());
}
};
threadpoolMonitoredObject.addAttribute(b1);
LongMonitoredAttributeBase b2 = new
LongMonitoredAttributeBase(MonitoringConstants.THREADPOOL_NUMBER_OF_AVAILABLE_THREADS,
MonitoringConstants.THREADPOOL_CURRENT_NUMBER_OF_THREADS_DESCRIPTION) {
public Object getValue() {
return new Long(ThreadPoolImpl.this.numberOfAvailableThreads());
}
};
threadpoolMonitoredObject.addAttribute(b2);
LongMonitoredAttributeBase b3 = new
LongMonitoredAttributeBase(MonitoringConstants.THREADPOOL_NUMBER_OF_BUSY_THREADS,
MonitoringConstants.THREADPOOL_NUMBER_OF_BUSY_THREADS_DESCRIPTION) {
public Object getValue() {
return new Long(ThreadPoolImpl.this.numberOfBusyThreads());
}
};
threadpoolMonitoredObject.addAttribute(b3);
LongMonitoredAttributeBase b4 = new
LongMonitoredAttributeBase(MonitoringConstants.THREADPOOL_AVERAGE_WORK_COMPLETION_TIME,
MonitoringConstants.THREADPOOL_AVERAGE_WORK_COMPLETION_TIME_DESCRIPTION) {
public Object getValue() {
return new Long(ThreadPoolImpl.this.averageWorkCompletionTime());
}
};
threadpoolMonitoredObject.addAttribute(b4);
LongMonitoredAttributeBase b5 = new
LongMonitoredAttributeBase(MonitoringConstants.THREADPOOL_CURRENT_PROCESSED_COUNT,
MonitoringConstants.THREADPOOL_CURRENT_PROCESSED_COUNT_DESCRIPTION) {
public Object getValue() {
return new Long(ThreadPoolImpl.this.currentProcessedCount());
}
};
threadpoolMonitoredObject.addAttribute(b5);
// Add the monitored object for the WorkQueue
threadpoolMonitoredObject.addChild(
((WorkQueueImpl)workQueue).getMonitoredObject());
|
| public int | maximumNumberOfThreads()This method will return the maximum number of threads in the
threadpool at any point in time, for the life of the threadpool
return maxWorkerThreads;
|
| public int | minimumNumberOfThreads()This method will return the minimum number of threads maintained
by the threadpool.
return minWorkerThreads;
|
| void | notifyForAvailableWork(com.sun.corba.se.spi.orbutil.threadpool.WorkQueue aWorkQueue)To be called from the workqueue when work is added to the
workQueue. This method would create new threads if required
or notify waiting threads on the queue for available work
synchronized (lock) {
if (availableWorkerThreads == 0) {
createWorkerThread();
} else {
aWorkQueue.notify();
}
}
|
| public int | numberOfAvailableThreads()This method will return the number of available threads in the
threadpool which are waiting for work. This method returns a
value which is not synchronized.
synchronized (lock) {
return availableWorkerThreads;
}
|
| public int | numberOfBusyThreads()This method will return the number of busy threads in the threadpool
This method returns a value which is not synchronized.
synchronized (lock) {
return (currentThreadCount - availableWorkerThreads);
}
|
| public int | numberOfWorkQueues()This method will return the number of WorkQueues serviced by the threadpool.
return 1;
|
