4:14 a.m.
Author: thomas.diesler(a)jboss.com
Date: 2009-01-27 05:14:30 -0500 (Tue, 27 Jan 2009)
New Revision: 3723
Modified:
jbpm3/trunk/modules/core/src/main/java/org/jbpm/job/executor/JobExecutor.java
Log:
[JBPM-1989] Null Pointer Exception in jBPM JobExecutor on server shutdown
Modified: jbpm3/trunk/modules/core/src/main/java/org/jbpm/job/executor/JobExecutor.java
===================================================================
---
jbpm3/trunk/modules/core/src/main/java/org/jbpm/job/executor/JobExecutor.java 2009-01-27
10:06:02 UTC (rev 3722)
+++
jbpm3/trunk/modules/core/src/main/java/org/jbpm/job/executor/JobExecutor.java 2009-01-27
10:14:30 UTC (rev 3723)
@@ -15,8 +15,8 @@
import org.apache.commons.logging.LogFactory;
import org.jbpm.JbpmConfiguration;
-public class JobExecutor implements Serializable {
-
+public class JobExecutor implements Serializable
+{
private static final long serialVersionUID = 1L;
protected JbpmConfiguration jbpmConfiguration;
@@ -38,53 +38,65 @@
protected static String hostName;
- public synchronized void start() {
- if (!isStarted) {
+ public synchronized void start()
+ {
+ if (!isStarted)
+ {
log.debug("starting thread group '" + name + "'...");
- for (int i = 0; i < nbrOfThreads; i++) {
+ for (int i = 0; i < nbrOfThreads; i++)
+ {
startThread();
}
- lockMonitorThread = new LockMonitorThread(jbpmConfiguration, lockMonitorInterval,
- maxLockTime, lockBufferTime);
+ lockMonitorThread = new LockMonitorThread(jbpmConfiguration, lockMonitorInterval,
maxLockTime, lockBufferTime);
isStarted = true;
}
- else {
+ else
+ {
log.debug("ignoring start: thread group '" + name + "' is
already started'");
}
}
- /**
- * signals to all threads in this job executor to stop. It may be that threads are in
the middle
- * of something and they will finish that first. Use {@link #stopAndJoin()} in case you
want a
- * method that blocks until all the threads are actually finished.
- *
- * @return a list of all the stopped threads. In case no threads were stopped an empty
list will
- * be returned.
+ /*
+ * signals to all threads in this job executor to stop. It may be that threads are in
the middle of something and they will finish that first. Use {@link
+ * #stopAndJoin()} in case you want a method that blocks until all the threads are
actually finished.
+ * @return a list of all the stopped threads. In case no threads were stopped an empty
list will be returned.
*/
- public synchronized List<Thread> stop() {
+ public synchronized List<Thread> stop()
+ {
List<Thread> stoppedThreads = new ArrayList<Thread>(threads.size());
- if (isStarted) {
+ if (isStarted)
+ {
log.debug("stopping thread group '" + name + "'...");
- for (int i = 0; i < nbrOfThreads; i++) {
+ for (int i = 0; i < nbrOfThreads; i++)
+ {
stoppedThreads.add(stopThread());
}
- lockMonitorThread.deactivate();
+
+ if (lockMonitorThread != null)
+ lockMonitorThread.deactivate();
+
isStarted = false;
}
- else {
+ else
+ {
log.debug("ignoring stop: thread group '" + name + "' not
started");
}
return stoppedThreads;
}
- public void stopAndJoin() throws InterruptedException {
- for (Thread thread : stop()) {
+ public void stopAndJoin() throws InterruptedException
+ {
+ for (Thread thread : stop())
+ {
thread.join();
}
- lockMonitorThread.join();
+
+ if (lockMonitorThread != null)
+ lockMonitorThread.join();
}
- protected synchronized void startThread() {
+ protected synchronized void startThread()
+ {
String threadName = getNextThreadName();
Thread thread = createThread(threadName);
threads.put(threadName, thread);
@@ -92,166 +104,203 @@
thread.start();
}
- protected Thread createThread(String threadName) {
+ protected Thread createThread(String threadName)
+ {
return new JobExecutorThread(threadName, this);
}
- protected String getNextThreadName() {
+ protected String getNextThreadName()
+ {
return getThreadName(threads.size() + 1);
}
- protected String getLastThreadName() {
+ protected String getLastThreadName()
+ {
return getThreadName(threads.size());
}
- private String getThreadName(int index) {
+ private String getThreadName(int index)
+ {
return name + ":" + getHostAddress() + ":" + index;
}
- private static String getHostAddress() {
- if (hostName == null) {
- try {
+ private static String getHostAddress()
+ {
+ if (hostName == null)
+ {
+ try
+ {
hostName = InetAddress.getLocalHost().getHostAddress();
}
- catch (UnknownHostException e) {
+ catch (UnknownHostException e)
+ {
hostName = "127.0.0.1";
}
}
return hostName;
}
- protected synchronized Thread stopThread() {
+ protected synchronized Thread stopThread()
+ {
String threadName = getLastThreadName();
- JobExecutorThread thread = (JobExecutorThread) threads.remove(threadName);
+ JobExecutorThread thread = (JobExecutorThread)threads.remove(threadName);
log.debug("removing job executor thread '" + threadName +
"'");
thread.deactivate();
return thread;
}
- public Set<Long> getMonitoredJobIds() {
+ public Set<Long> getMonitoredJobIds()
+ {
return new HashSet<Long>(monitoredJobIds.values());
}
- public void addMonitoredJobId(String threadName, long jobId) {
+ public void addMonitoredJobId(String threadName, long jobId)
+ {
monitoredJobIds.put(threadName, new Long(jobId));
}
- public void removeMonitoredJobId(String threadName) {
+ public void removeMonitoredJobId(String threadName)
+ {
monitoredJobIds.remove(threadName);
}
- /**
+ /*
* @throws UnsupportedOperationException to prevent invocation
* @deprecated <code>monitoredJobIds</code> is an internal control field
*/
- public void setMonitoredJobIds(Map<String, Long> monitoredJobIds) {
+ public void setMonitoredJobIds(Map<String, Long> monitoredJobIds)
+ {
throw new UnsupportedOperationException();
}
- public int getHistoryMaxSize() {
+ public int getHistoryMaxSize()
+ {
return historyMaxSize;
}
- public void setHistoryMaxSize(int historyMaxSize) {
+ public void setHistoryMaxSize(int historyMaxSize)
+ {
this.historyMaxSize = historyMaxSize;
}
- public int getIdleInterval() {
+ public int getIdleInterval()
+ {
return idleInterval;
}
- public void setIdleInterval(int idleInterval) {
+ public void setIdleInterval(int idleInterval)
+ {
this.idleInterval = idleInterval;
}
- /**
+ /*
* Tells whether this job executor has been {@linkplain #start() started}.
*/
- public boolean isStarted() {
+ public boolean isStarted()
+ {
return isStarted;
}
- /**
+ /*
* @throws UnsupportedOperationException to prevent invocation
* @deprecated <code>isStarted</code> is an internal control field
*/
- public void setStarted(boolean isStarted) {
+ public void setStarted(boolean isStarted)
+ {
throw new UnsupportedOperationException();
}
- public JbpmConfiguration getJbpmConfiguration() {
+ public JbpmConfiguration getJbpmConfiguration()
+ {
return jbpmConfiguration;
}
- public void setJbpmConfiguration(JbpmConfiguration jbpmConfiguration) {
+ public void setJbpmConfiguration(JbpmConfiguration jbpmConfiguration)
+ {
this.jbpmConfiguration = jbpmConfiguration;
}
- public int getMaxIdleInterval() {
+ public int getMaxIdleInterval()
+ {
return maxIdleInterval;
}
- public void setMaxIdleInterval(int maxIdleInterval) {
+ public void setMaxIdleInterval(int maxIdleInterval)
+ {
this.maxIdleInterval = maxIdleInterval;
}
- public String getName() {
+ public String getName()
+ {
return name;
}
- public void setName(String name) {
+ public void setName(String name)
+ {
this.name = name;
}
- public int getSize() {
+ public int getSize()
+ {
return nbrOfThreads;
}
- public void setSize(int nbrOfThreads) {
+ public void setSize(int nbrOfThreads)
+ {
this.nbrOfThreads = nbrOfThreads;
}
- public Map<String, Thread> getThreads() {
+ public Map<String, Thread> getThreads()
+ {
return threads;
}
- /**
+ /*
* @throws UnsupportedOperationException to prevent invocation
* @deprecated <code>thread</code> is an internal control field
*/
- public void setThreads(Map<String, Thread> threads) {
+ public void setThreads(Map<String, Thread> threads)
+ {
throw new UnsupportedOperationException();
}
- public int getMaxLockTime() {
+ public int getMaxLockTime()
+ {
return maxLockTime;
}
- public void setMaxLockTime(int maxLockTime) {
+ public void setMaxLockTime(int maxLockTime)
+ {
this.maxLockTime = maxLockTime;
}
- public int getLockBufferTime() {
+ public int getLockBufferTime()
+ {
return lockBufferTime;
}
- public void setLockBufferTime(int lockBufferTime) {
+ public void setLockBufferTime(int lockBufferTime)
+ {
this.lockBufferTime = lockBufferTime;
}
- public int getLockMonitorInterval() {
+ public int getLockMonitorInterval()
+ {
return lockMonitorInterval;
}
- public void setLockMonitorInterval(int lockMonitorInterval) {
+ public void setLockMonitorInterval(int lockMonitorInterval)
+ {
this.lockMonitorInterval = lockMonitorInterval;
}
- public int getNbrOfThreads() {
+ public int getNbrOfThreads()
+ {
return nbrOfThreads;
}
- public void setNbrOfThreads(int nbrOfThreads) {
+ public void setNbrOfThreads(int nbrOfThreads)
+ {
this.nbrOfThreads = nbrOfThreads;
}