17 changed files with 1403 additions and 42 deletions
Binary file not shown.
@ -0,0 +1,10 @@ |
|||||
|
package org.nl.acs.device_driver; |
||||
|
|
||||
|
public interface HeartbeatableDeviceDriver extends DeviceDriver { |
||||
|
default void checkHeartbeat() { |
||||
|
} |
||||
|
|
||||
|
default boolean isOnline() { |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,92 @@ |
|||||
|
package org.nl.acs.heartbeat; |
||||
|
|
||||
|
import lombok.extern.slf4j.Slf4j; |
||||
|
import org.nl.acs.auto.run.AbstractAutoRunnable; |
||||
|
import org.nl.acs.auto.run.SystemConfig; |
||||
|
import org.nl.acs.device_driver.HeartbeatableDeviceDriver; |
||||
|
import org.nl.acs.opc.*; |
||||
|
import org.springframework.beans.factory.annotation.Autowired; |
||||
|
import org.springframework.stereotype.Component; |
||||
|
|
||||
|
import java.util.*; |
||||
|
import java.util.concurrent.ExecutorService; |
||||
|
|
||||
|
@Slf4j |
||||
|
@Component |
||||
|
public class DeviceHeartbeatExecuteAutoRun extends AbstractAutoRunnable { |
||||
|
|
||||
|
@Autowired |
||||
|
DeviceAppService deviceAppService; |
||||
|
int initial_thread = 2; |
||||
|
int max_thread = 10; |
||||
|
int cache_thread = 5; |
||||
|
int loop_time_millions = 300; |
||||
|
ExecutorService executorService; |
||||
|
Map<String, BlockedRunable> runs; |
||||
|
|
||||
|
public DeviceHeartbeatExecuteAutoRun() { |
||||
|
this.executorService = ThreadPoolUtl.newIncreasedBlockedThreadPool(this.initial_thread, this.max_thread, this.cache_thread); |
||||
|
this.runs = new LinkedHashMap(); |
||||
|
this.runs = Collections.synchronizedMap(this.runs); |
||||
|
} |
||||
|
|
||||
|
public String getCode() { |
||||
|
return DeviceHeartbeatExecuteAutoRun.class.getSimpleName(); |
||||
|
} |
||||
|
|
||||
|
public String getName() { |
||||
|
return "设备在线监听"; |
||||
|
} |
||||
|
|
||||
|
public void autoRun() { |
||||
|
while(true) { |
||||
|
ThreadUtl.sleep((long)this.loop_time_millions); |
||||
|
if (SystemConfig.heartbeat_no_use) { |
||||
|
return; |
||||
|
} |
||||
|
if(!DeviceOpcSynchronizeAutoRun.isRun){ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
List<HeartbeatableDeviceDriver> deviceDrivers = this.deviceAppService.findDeviceDriver(HeartbeatableDeviceDriver.class); |
||||
|
Iterator var2 = deviceDrivers.iterator(); |
||||
|
|
||||
|
while(var2.hasNext()) { |
||||
|
final HeartbeatableDeviceDriver deviceDriver = (HeartbeatableDeviceDriver)var2.next(); |
||||
|
if (deviceDriver.getDevice().getIs_config() != null && deviceDriver.getDevice().getIs_config() && !this.runs.keySet().contains(deviceDriver.getDeviceCode())) { |
||||
|
BlockedRunable runable = new BlockedRunable() { |
||||
|
public void subRun() { |
||||
|
deviceDriver.checkHeartbeat(); |
||||
|
} |
||||
|
|
||||
|
public String getCode() { |
||||
|
return deviceDriver.getDeviceCode(); |
||||
|
} |
||||
|
}; |
||||
|
if (!this.runs.keySet().contains(deviceDriver.getDeviceCode())) { |
||||
|
this.runs.put(deviceDriver.getDeviceCode(), runable); |
||||
|
} |
||||
|
|
||||
|
runable.setIndex(this.runs); |
||||
|
this.executorService.submit(runable); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public void after() { |
||||
|
this.executorService.shutdownNow(); |
||||
|
this.executorService = ThreadPoolUtl.newIncreasedBlockedThreadPool(this.initial_thread, this.max_thread, this.cache_thread); |
||||
|
this.runs = new LinkedHashMap(); |
||||
|
this.runs = Collections.synchronizedMap(this.runs); |
||||
|
} |
||||
|
|
||||
|
public ExecutorService getExecutorService() { |
||||
|
return this.executorService; |
||||
|
} |
||||
|
|
||||
|
public Map<String, BlockedRunable> getRuns() { |
||||
|
return this.runs; |
||||
|
} |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,10 @@ |
|||||
|
package org.nl.acs.heartbeat; |
||||
|
|
||||
|
public class HeartbeatConfig { |
||||
|
|
||||
|
/** |
||||
|
* 最大心跳时常 |
||||
|
*/ |
||||
|
public static Integer max_alive_time_millions = 1000 * 30; |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,56 @@ |
|||||
|
package org.nl.acs.heartbeat; |
||||
|
|
||||
|
import lombok.extern.slf4j.Slf4j; |
||||
|
import org.nl.acs.auto.run.AbstractAutoRunnable; |
||||
|
import org.nl.acs.auto.run.AutoRunService; |
||||
|
import org.nl.acs.heartbeat.service.HeartbeatUnifiedService; |
||||
|
import org.nl.acs.heartbeat.service_impl.HeartbeatUnifiedServiceimpl; |
||||
|
import org.nl.acs.opc.ThreadUtl; |
||||
|
import org.nl.modules.wql.util.SpringContextHolder; |
||||
|
import org.springframework.beans.factory.annotation.Autowired; |
||||
|
import org.springframework.stereotype.Component; |
||||
|
|
||||
|
import java.util.Date; |
||||
|
|
||||
|
@Slf4j |
||||
|
@Component |
||||
|
public class HeartbeatOfflineCheckerAutoRun extends AbstractAutoRunnable { |
||||
|
@Autowired |
||||
|
AutoRunService autoRunService; |
||||
|
|
||||
|
private int recordTimeOut = 10000; |
||||
|
private Date recordTime; |
||||
|
int offline_loop_time_millions = 1000; |
||||
|
boolean heartbeat_no_use =false; |
||||
|
public HeartbeatOfflineCheckerAutoRun() { |
||||
|
this.recordTime = new Date((new Date()).getTime() - (long)this.recordTimeOut); |
||||
|
} |
||||
|
|
||||
|
public String getCode() { |
||||
|
return HeartbeatOfflineCheckerAutoRun.class.getSimpleName(); |
||||
|
} |
||||
|
|
||||
|
public String getName() { |
||||
|
return "在线监听器"; |
||||
|
} |
||||
|
|
||||
|
public void autoRun() { |
||||
|
HeartbeatUnifiedService heartbeatUnifiedService = SpringContextHolder.getBean(HeartbeatUnifiedServiceimpl.class); |
||||
|
|
||||
|
for(; !heartbeat_no_use; ThreadUtl.sleep((long)offline_loop_time_millions)) { |
||||
|
try { |
||||
|
heartbeatUnifiedService.offlineChecker(); |
||||
|
} catch (Exception var3) { |
||||
|
Date date = new Date(); |
||||
|
if (date.getTime() - this.recordTime.getTime() < (long)this.recordTimeOut) { |
||||
|
log.trace("离线事件异常发生时间因为小于{}毫秒，而被无视", this.recordTime); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
this.recordTime = date; |
||||
|
log.warn("", var3); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,25 @@ |
|||||
|
package org.nl.acs.opc; |
||||
|
|
||||
|
import org.slf4j.Logger; |
||||
|
import org.slf4j.LoggerFactory; |
||||
|
|
||||
|
import java.util.concurrent.RejectedExecutionHandler; |
||||
|
import java.util.concurrent.ThreadPoolExecutor; |
||||
|
|
||||
|
public class BlockedThreadPoolPolicy implements RejectedExecutionHandler { |
||||
|
private static final Logger log = LoggerFactory.getLogger(BlockedThreadPoolPolicy.class); |
||||
|
|
||||
|
public BlockedThreadPoolPolicy() { |
||||
|
} |
||||
|
|
||||
|
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { |
||||
|
if (!e.isShutdown()) { |
||||
|
try { |
||||
|
e.getQueue().put(r); |
||||
|
} catch (InterruptedException var4) { |
||||
|
log.debug("", var4); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,22 @@ |
|||||
|
package org.nl.acs.opc; |
||||
|
|
||||
|
import org.slf4j.Logger; |
||||
|
import org.slf4j.LoggerFactory; |
||||
|
|
||||
|
public class IncreasedBlokdedThreadPoolPolicy implements IncreasedRejectedExecutionHandler { |
||||
|
private static final Logger log = LoggerFactory.getLogger(IncreasedBlokdedThreadPoolPolicy.class); |
||||
|
|
||||
|
public IncreasedBlokdedThreadPoolPolicy() { |
||||
|
} |
||||
|
|
||||
|
public void rejectedExecution(Runnable r, IncreasedThreadPoolExecutor e) { |
||||
|
if (!e.isShutdown()) { |
||||
|
try { |
||||
|
e.getQueue().put(r); |
||||
|
} catch (InterruptedException var4) { |
||||
|
log.debug("", var4); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,5 @@ |
|||||
|
package org.nl.acs.opc; |
||||
|
|
||||
|
public interface IncreasedRejectedExecutionHandler { |
||||
|
void rejectedExecution(Runnable var1, IncreasedThreadPoolExecutor var2); |
||||
|
} |
||||
@ -0,0 +1,943 @@ |
|||||
|
package org.nl.acs.opc; |
||||
|
|
||||
|
import java.util.*; |
||||
|
import java.util.concurrent.*; |
||||
|
import java.util.concurrent.atomic.AtomicInteger; |
||||
|
import java.util.concurrent.locks.AbstractQueuedSynchronizer; |
||||
|
import java.util.concurrent.locks.Condition; |
||||
|
import java.util.concurrent.locks.ReentrantLock; |
||||
|
|
||||
|
public class IncreasedThreadPoolExecutor extends AbstractExecutorService { |
||||
|
private final AtomicInteger ctl; |
||||
|
private static final int COUNT_BITS = 29; |
||||
|
private static final int CAPACITY = 536870911; |
||||
|
private static final int RUNNING = -536870912; |
||||
|
private static final int SHUTDOWN = 0; |
||||
|
private static final int STOP = 536870912; |
||||
|
private static final int TIDYING = 1073741824; |
||||
|
private static final int TERMINATED = 1610612736; |
||||
|
private final BlockingQueue<Runnable> workQueue; |
||||
|
private final ReentrantLock mainLock; |
||||
|
private final HashSet<Worker> workers; |
||||
|
private final Condition termination; |
||||
|
private int largestPoolSize; |
||||
|
private long completedTaskCount; |
||||
|
private volatile ThreadFactory threadFactory; |
||||
|
private volatile IncreasedRejectedExecutionHandler handler; |
||||
|
private volatile long keepAliveTime; |
||||
|
private volatile boolean allowCoreThreadTimeOut; |
||||
|
private volatile int corePoolSize; |
||||
|
private volatile int maximumPoolSize; |
||||
|
private volatile int multiple; |
||||
|
private static final IncreasedRejectedExecutionHandler defaultHandler = new AbortPolicy(); |
||||
|
private static final RuntimePermission shutdownPerm = new RuntimePermission("modifyThread"); |
||||
|
private static final boolean ONLY_ONE = true; |
||||
|
|
||||
|
private static int runStateOf(int c) { |
||||
|
return c & -536870912; |
||||
|
} |
||||
|
|
||||
|
private static int workerCountOf(int c) { |
||||
|
return c & 536870911; |
||||
|
} |
||||
|
|
||||
|
private static int ctlOf(int rs, int wc) { |
||||
|
return rs | wc; |
||||
|
} |
||||
|
|
||||
|
private static boolean runStateLessThan(int c, int s) { |
||||
|
return c < s; |
||||
|
} |
||||
|
|
||||
|
private static boolean runStateAtLeast(int c, int s) { |
||||
|
return c >= s; |
||||
|
} |
||||
|
|
||||
|
private static boolean isRunning(int c) { |
||||
|
return c < 0; |
||||
|
} |
||||
|
|
||||
|
private boolean compareAndIncrementWorkerCount(int expect) { |
||||
|
return this.ctl.compareAndSet(expect, expect + 1); |
||||
|
} |
||||
|
|
||||
|
private boolean compareAndDecrementWorkerCount(int expect) { |
||||
|
return this.ctl.compareAndSet(expect, expect - 1); |
||||
|
} |
||||
|
|
||||
|
private void decrementWorkerCount() { |
||||
|
while(!this.compareAndDecrementWorkerCount(this.ctl.get())) { |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
private void advanceRunState(int targetState) { |
||||
|
int c; |
||||
|
do { |
||||
|
c = this.ctl.get(); |
||||
|
} while(!runStateAtLeast(c, targetState) && !this.ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c)))); |
||||
|
|
||||
|
} |
||||
|
|
||||
|
final void tryTerminate() { |
||||
|
while(true) { |
||||
|
int c = this.ctl.get(); |
||||
|
if (isRunning(c) || runStateAtLeast(c, 1073741824) || runStateOf(c) == 0 && !this.workQueue.isEmpty()) { |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (workerCountOf(c) != 0) { |
||||
|
this.interruptIdleWorkers(true); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
try { |
||||
|
if (!this.ctl.compareAndSet(c, ctlOf(1073741824, 0))) { |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
try { |
||||
|
this.terminated(); |
||||
|
} finally { |
||||
|
this.ctl.set(ctlOf(1610612736, 0)); |
||||
|
this.termination.signalAll(); |
||||
|
} |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void checkShutdownAccess() { |
||||
|
SecurityManager security = System.getSecurityManager(); |
||||
|
if (security != null) { |
||||
|
security.checkPermission(shutdownPerm); |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
try { |
||||
|
Iterator var3 = this.workers.iterator(); |
||||
|
|
||||
|
while(var3.hasNext()) { |
||||
|
Worker w = (Worker)var3.next(); |
||||
|
security.checkAccess(w.thread); |
||||
|
} |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
private void interruptWorkers() { |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
try { |
||||
|
Iterator var2 = this.workers.iterator(); |
||||
|
|
||||
|
while(var2.hasNext()) { |
||||
|
Worker w = (Worker)var2.next(); |
||||
|
w.interruptIfStarted(); |
||||
|
} |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
private void interruptIdleWorkers(boolean onlyOne) { |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
try { |
||||
|
Iterator var3 = this.workers.iterator(); |
||||
|
|
||||
|
while(var3.hasNext()) { |
||||
|
Worker w = (Worker)var3.next(); |
||||
|
Thread t = w.thread; |
||||
|
if (!t.isInterrupted() && w.tryLock()) { |
||||
|
try { |
||||
|
t.interrupt(); |
||||
|
} catch (SecurityException var15) { |
||||
|
} finally { |
||||
|
w.unlock(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (onlyOne) { |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
private void interruptIdleWorkers() { |
||||
|
this.interruptIdleWorkers(false); |
||||
|
} |
||||
|
|
||||
|
final void reject(Runnable command) { |
||||
|
this.handler.rejectedExecution(command, this); |
||||
|
} |
||||
|
|
||||
|
void onShutdown() { |
||||
|
} |
||||
|
|
||||
|
final boolean isRunningOrShutdown(boolean shutdownOK) { |
||||
|
int rs = runStateOf(this.ctl.get()); |
||||
|
return rs == -536870912 || rs == 0 && shutdownOK; |
||||
|
} |
||||
|
|
||||
|
private List<Runnable> drainQueue() { |
||||
|
BlockingQueue<Runnable> q = this.workQueue; |
||||
|
ArrayList<Runnable> taskList = new ArrayList(); |
||||
|
q.drainTo(taskList); |
||||
|
if (!q.isEmpty()) { |
||||
|
Runnable[] var3 = (Runnable[])q.toArray(new Runnable[0]); |
||||
|
int var4 = var3.length; |
||||
|
|
||||
|
for(int var5 = 0; var5 < var4; ++var5) { |
||||
|
Runnable r = var3[var5]; |
||||
|
if (q.remove(r)) { |
||||
|
taskList.add(r); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return taskList; |
||||
|
} |
||||
|
|
||||
|
private boolean addWorker(Runnable firstTask, boolean core) { |
||||
|
while(true) { |
||||
|
int c = this.ctl.get(); |
||||
|
int rs = runStateOf(c); |
||||
|
if (rs >= 0 && (rs != 0 || firstTask != null || this.workQueue.isEmpty())) { |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
while(true) { |
||||
|
int wc = workerCountOf(c); |
||||
|
if (wc >= 536870911 || wc >= (core ? this.corePoolSize : this.maximumPoolSize)) { |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
if (this.compareAndIncrementWorkerCount(c)) { |
||||
|
boolean workerStarted = false; |
||||
|
boolean workerAdded = false; |
||||
|
Worker w = null; |
||||
|
|
||||
|
try { |
||||
|
w = new Worker(firstTask); |
||||
|
Thread t = w.thread; |
||||
|
if (t != null) { |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
try { |
||||
|
int rs1 = runStateOf(this.ctl.get()); |
||||
|
if (rs1 < 0 || rs1 == 0 && firstTask == null) { |
||||
|
if (t.isAlive()) { |
||||
|
throw new IllegalThreadStateException(); |
||||
|
} |
||||
|
|
||||
|
this.workers.add(w); |
||||
|
int s = this.workers.size(); |
||||
|
if (s > this.largestPoolSize) { |
||||
|
this.largestPoolSize = s; |
||||
|
} |
||||
|
|
||||
|
workerAdded = true; |
||||
|
} |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
|
||||
|
if (workerAdded) { |
||||
|
t.start(); |
||||
|
workerStarted = true; |
||||
|
} |
||||
|
} |
||||
|
} finally { |
||||
|
if (!workerStarted) { |
||||
|
this.addWorkerFailed(w); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
return workerStarted; |
||||
|
} |
||||
|
|
||||
|
c = this.ctl.get(); |
||||
|
if (runStateOf(c) != rs) { |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void addWorkerFailed(Worker w) { |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
try { |
||||
|
if (w != null) { |
||||
|
this.workers.remove(w); |
||||
|
} |
||||
|
|
||||
|
this.decrementWorkerCount(); |
||||
|
this.tryTerminate(); |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
private void processWorkerExit(Worker w, boolean completedAbruptly) { |
||||
|
if (completedAbruptly) { |
||||
|
this.decrementWorkerCount(); |
||||
|
} |
||||
|
|
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
try { |
||||
|
this.completedTaskCount += w.completedTasks; |
||||
|
this.workers.remove(w); |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
|
||||
|
this.tryTerminate(); |
||||
|
int c = this.ctl.get(); |
||||
|
if (runStateLessThan(c, 536870912)) { |
||||
|
if (!completedAbruptly) { |
||||
|
int min = this.allowCoreThreadTimeOut ? 0 : this.corePoolSize; |
||||
|
if (min == 0 && !this.workQueue.isEmpty()) { |
||||
|
min = 1; |
||||
|
} |
||||
|
|
||||
|
if (workerCountOf(c) >= min) { |
||||
|
return; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
this.addWorker((Runnable)null, false); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
private Runnable getTask() { |
||||
|
boolean timedOut = false; |
||||
|
|
||||
|
while(true) { |
||||
|
int c = this.ctl.get(); |
||||
|
int rs = runStateOf(c); |
||||
|
if (rs >= 0 && (rs >= 536870912 || this.workQueue.isEmpty())) { |
||||
|
this.decrementWorkerCount(); |
||||
|
return null; |
||||
|
} |
||||
|
|
||||
|
int wc = workerCountOf(c); |
||||
|
boolean timed = this.allowCoreThreadTimeOut || wc > this.corePoolSize; |
||||
|
if (wc <= this.maximumPoolSize && (!timed || !timedOut) || wc <= 1 && !this.workQueue.isEmpty()) { |
||||
|
try { |
||||
|
Runnable r = timed ? (Runnable)this.workQueue.poll(this.keepAliveTime, TimeUnit.NANOSECONDS) : (Runnable)this.workQueue.take(); |
||||
|
if (r != null) { |
||||
|
return r; |
||||
|
} |
||||
|
|
||||
|
timedOut = true; |
||||
|
} catch (InterruptedException var7) { |
||||
|
timedOut = false; |
||||
|
} |
||||
|
} else if (this.compareAndDecrementWorkerCount(c)) { |
||||
|
return null; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
final void runWorker(Worker w) { |
||||
|
Thread wt = Thread.currentThread(); |
||||
|
Runnable task = w.firstTask; |
||||
|
w.firstTask = null; |
||||
|
w.unlock(); |
||||
|
boolean completedAbruptly = true; |
||||
|
|
||||
|
try { |
||||
|
while(task != null || (task = this.getTask()) != null) { |
||||
|
w.lock(); |
||||
|
if ((runStateAtLeast(this.ctl.get(), 536870912) || Thread.interrupted() && runStateAtLeast(this.ctl.get(), 536870912)) && !wt.isInterrupted()) { |
||||
|
wt.interrupt(); |
||||
|
} |
||||
|
|
||||
|
try { |
||||
|
this.beforeExecute(wt, task); |
||||
|
Throwable thrown = null; |
||||
|
|
||||
|
try { |
||||
|
task.run(); |
||||
|
} catch (RuntimeException var28) { |
||||
|
thrown = var28; |
||||
|
throw var28; |
||||
|
} catch (Error var29) { |
||||
|
thrown = var29; |
||||
|
throw var29; |
||||
|
} catch (Throwable var30) { |
||||
|
thrown = var30; |
||||
|
throw new Error(var30); |
||||
|
} finally { |
||||
|
this.afterExecute(task, (Throwable)thrown); |
||||
|
} |
||||
|
} finally { |
||||
|
task = null; |
||||
|
++w.completedTasks; |
||||
|
w.unlock(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
completedAbruptly = false; |
||||
|
} finally { |
||||
|
this.processWorkerExit(w, completedAbruptly); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
public IncreasedThreadPoolExecutor(int corePoolSize, int maximumPoolSize, int multiple, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) { |
||||
|
this(corePoolSize, maximumPoolSize, multiple, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler); |
||||
|
} |
||||
|
|
||||
|
public IncreasedThreadPoolExecutor(int corePoolSize, int maximumPoolSize, int multiple, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) { |
||||
|
this(corePoolSize, maximumPoolSize, multiple, keepAliveTime, unit, workQueue, threadFactory, defaultHandler); |
||||
|
} |
||||
|
|
||||
|
public IncreasedThreadPoolExecutor(int corePoolSize, int maximumPoolSize, int multiple, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, IncreasedRejectedExecutionHandler handler) { |
||||
|
this(corePoolSize, maximumPoolSize, multiple, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), handler); |
||||
|
} |
||||
|
|
||||
|
public IncreasedThreadPoolExecutor(int corePoolSize, int maximumPoolSize, int multiple, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, IncreasedRejectedExecutionHandler handler) { |
||||
|
this.ctl = new AtomicInteger(ctlOf(-536870912, 0)); |
||||
|
this.mainLock = new ReentrantLock(); |
||||
|
this.workers = new HashSet(); |
||||
|
this.termination = this.mainLock.newCondition(); |
||||
|
if (corePoolSize >= 0 && maximumPoolSize > 0 && maximumPoolSize >= corePoolSize && keepAliveTime >= 0L) { |
||||
|
if (workQueue != null && threadFactory != null && handler != null) { |
||||
|
this.corePoolSize = corePoolSize; |
||||
|
this.maximumPoolSize = maximumPoolSize; |
||||
|
this.workQueue = workQueue; |
||||
|
this.keepAliveTime = unit.toNanos(keepAliveTime); |
||||
|
this.threadFactory = threadFactory; |
||||
|
this.handler = handler; |
||||
|
this.multiple = multiple; |
||||
|
} else { |
||||
|
throw new NullPointerException(); |
||||
|
} |
||||
|
} else { |
||||
|
throw new IllegalArgumentException(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public void execute(Runnable command) { |
||||
|
if (command == null) { |
||||
|
throw new NullPointerException(); |
||||
|
} else { |
||||
|
int c = this.ctl.get(); |
||||
|
if (workerCountOf(c) < this.corePoolSize) { |
||||
|
if (this.addWorker(command, true)) { |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
c = this.ctl.get(); |
||||
|
} |
||||
|
|
||||
|
if (isRunning(c) && this.workQueue.size() < workerCountOf(c) * this.multiple && this.workQueue.offer(command)) { |
||||
|
int recheck = this.ctl.get(); |
||||
|
if (!isRunning(recheck) && this.remove(command)) { |
||||
|
this.reject(command); |
||||
|
} else if (workerCountOf(recheck) == 0) { |
||||
|
this.addWorker((Runnable)null, false); |
||||
|
} |
||||
|
} else if (!this.addWorker(command, false)) { |
||||
|
this.reject(command); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public void shutdown() { |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
try { |
||||
|
this.checkShutdownAccess(); |
||||
|
this.advanceRunState(0); |
||||
|
this.interruptIdleWorkers(); |
||||
|
this.onShutdown(); |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
|
||||
|
this.tryTerminate(); |
||||
|
} |
||||
|
|
||||
|
public List<Runnable> shutdownNow() { |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
List tasks; |
||||
|
try { |
||||
|
this.checkShutdownAccess(); |
||||
|
this.advanceRunState(536870912); |
||||
|
this.interruptWorkers(); |
||||
|
tasks = this.drainQueue(); |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
|
||||
|
this.tryTerminate(); |
||||
|
return tasks; |
||||
|
} |
||||
|
|
||||
|
public boolean isShutdown() { |
||||
|
return !isRunning(this.ctl.get()); |
||||
|
} |
||||
|
|
||||
|
public boolean isTerminating() { |
||||
|
int c = this.ctl.get(); |
||||
|
return !isRunning(c) && runStateLessThan(c, 1610612736); |
||||
|
} |
||||
|
|
||||
|
public boolean isTerminated() { |
||||
|
return runStateAtLeast(this.ctl.get(), 1610612736); |
||||
|
} |
||||
|
|
||||
|
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException { |
||||
|
long nanos = unit.toNanos(timeout); |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
boolean var7; |
||||
|
try { |
||||
|
while(!runStateAtLeast(this.ctl.get(), 1610612736)) { |
||||
|
if (nanos <= 0L) { |
||||
|
var7 = false; |
||||
|
return var7; |
||||
|
} |
||||
|
|
||||
|
nanos = this.termination.awaitNanos(nanos); |
||||
|
} |
||||
|
|
||||
|
var7 = true; |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
|
||||
|
return var7; |
||||
|
} |
||||
|
|
||||
|
protected void finalize() { |
||||
|
this.shutdown(); |
||||
|
} |
||||
|
|
||||
|
public void setThreadFactory(ThreadFactory threadFactory) { |
||||
|
if (threadFactory == null) { |
||||
|
throw new NullPointerException(); |
||||
|
} else { |
||||
|
this.threadFactory = threadFactory; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public ThreadFactory getThreadFactory() { |
||||
|
return this.threadFactory; |
||||
|
} |
||||
|
|
||||
|
public void setRejectedExecutionHandler(IncreasedRejectedExecutionHandler handler) { |
||||
|
if (handler == null) { |
||||
|
throw new NullPointerException(); |
||||
|
} else { |
||||
|
this.handler = handler; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public IncreasedRejectedExecutionHandler getRejectedExecutionHandler() { |
||||
|
return this.handler; |
||||
|
} |
||||
|
|
||||
|
public void setCorePoolSize(int corePoolSize) { |
||||
|
if (corePoolSize < 0) { |
||||
|
throw new IllegalArgumentException(); |
||||
|
} else { |
||||
|
int delta = corePoolSize - this.corePoolSize; |
||||
|
this.corePoolSize = corePoolSize; |
||||
|
if (workerCountOf(this.ctl.get()) > corePoolSize) { |
||||
|
this.interruptIdleWorkers(); |
||||
|
} else if (delta > 0) { |
||||
|
int k = Math.min(delta, this.workQueue.size()); |
||||
|
|
||||
|
while(k-- > 0 && this.addWorker((Runnable)null, true) && !this.workQueue.isEmpty()) { |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public int getCorePoolSize() { |
||||
|
return this.corePoolSize; |
||||
|
} |
||||
|
|
||||
|
public boolean prestartCoreThread() { |
||||
|
return workerCountOf(this.ctl.get()) < this.corePoolSize && this.addWorker((Runnable)null, true); |
||||
|
} |
||||
|
|
||||
|
void ensurePrestart() { |
||||
|
int wc = workerCountOf(this.ctl.get()); |
||||
|
if (wc < this.corePoolSize) { |
||||
|
this.addWorker((Runnable)null, true); |
||||
|
} else if (wc == 0) { |
||||
|
this.addWorker((Runnable)null, false); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
public int prestartAllCoreThreads() { |
||||
|
int n; |
||||
|
for(n = 0; this.addWorker((Runnable)null, true); ++n) { |
||||
|
} |
||||
|
|
||||
|
return n; |
||||
|
} |
||||
|
|
||||
|
public boolean allowsCoreThreadTimeOut() { |
||||
|
return this.allowCoreThreadTimeOut; |
||||
|
} |
||||
|
|
||||
|
public void allowCoreThreadTimeOut(boolean value) { |
||||
|
if (value && this.keepAliveTime <= 0L) { |
||||
|
throw new IllegalArgumentException("Core threads must have nonzero keep alive times"); |
||||
|
} else { |
||||
|
if (value != this.allowCoreThreadTimeOut) { |
||||
|
this.allowCoreThreadTimeOut = value; |
||||
|
if (value) { |
||||
|
this.interruptIdleWorkers(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public void setMaximumPoolSize(int maximumPoolSize) { |
||||
|
if (maximumPoolSize > 0 && maximumPoolSize >= this.corePoolSize) { |
||||
|
this.maximumPoolSize = maximumPoolSize; |
||||
|
if (workerCountOf(this.ctl.get()) > maximumPoolSize) { |
||||
|
this.interruptIdleWorkers(); |
||||
|
} |
||||
|
|
||||
|
} else { |
||||
|
throw new IllegalArgumentException(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public int getMaximumPoolSize() { |
||||
|
return this.maximumPoolSize; |
||||
|
} |
||||
|
|
||||
|
public void setKeepAliveTime(long time, TimeUnit unit) { |
||||
|
if (time < 0L) { |
||||
|
throw new IllegalArgumentException(); |
||||
|
} else if (time == 0L && this.allowsCoreThreadTimeOut()) { |
||||
|
throw new IllegalArgumentException("Core threads must have nonzero keep alive times"); |
||||
|
} else { |
||||
|
long keepAliveTime = unit.toNanos(time); |
||||
|
long delta = keepAliveTime - this.keepAliveTime; |
||||
|
this.keepAliveTime = keepAliveTime; |
||||
|
if (delta < 0L) { |
||||
|
this.interruptIdleWorkers(); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public long getKeepAliveTime(TimeUnit unit) { |
||||
|
return unit.convert(this.keepAliveTime, TimeUnit.NANOSECONDS); |
||||
|
} |
||||
|
|
||||
|
public BlockingQueue<Runnable> getQueue() { |
||||
|
return this.workQueue; |
||||
|
} |
||||
|
|
||||
|
public boolean remove(Runnable task) { |
||||
|
boolean removed = this.workQueue.remove(task); |
||||
|
this.tryTerminate(); |
||||
|
return removed; |
||||
|
} |
||||
|
|
||||
|
public void purge() { |
||||
|
BlockingQueue<Runnable> q = this.workQueue; |
||||
|
|
||||
|
try { |
||||
|
Iterator<Runnable> it = q.iterator(); |
||||
|
|
||||
|
while(it.hasNext()) { |
||||
|
Runnable r = (Runnable)it.next(); |
||||
|
if (r instanceof Future && ((Future)r).isCancelled()) { |
||||
|
it.remove(); |
||||
|
} |
||||
|
} |
||||
|
} catch (ConcurrentModificationException var7) { |
||||
|
Object[] var3 = q.toArray(); |
||||
|
int var4 = var3.length; |
||||
|
|
||||
|
for(int var5 = 0; var5 < var4; ++var5) { |
||||
|
Object r = var3[var5]; |
||||
|
if (r instanceof Future && ((Future)r).isCancelled()) { |
||||
|
q.remove(r); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
this.tryTerminate(); |
||||
|
} |
||||
|
|
||||
|
public int getPoolSize() { |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
int var2; |
||||
|
try { |
||||
|
var2 = runStateAtLeast(this.ctl.get(), 1073741824) ? 0 : this.workers.size(); |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
|
||||
|
return var2; |
||||
|
} |
||||
|
|
||||
|
public int getActiveCount() { |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
try { |
||||
|
int n = 0; |
||||
|
Iterator var3 = this.workers.iterator(); |
||||
|
|
||||
|
while(var3.hasNext()) { |
||||
|
Worker w = (Worker)var3.next(); |
||||
|
if (w.isLocked()) { |
||||
|
++n; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
int var8 = n; |
||||
|
return var8; |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public int getLargestPoolSize() { |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
int var2; |
||||
|
try { |
||||
|
var2 = this.largestPoolSize; |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
|
||||
|
return var2; |
||||
|
} |
||||
|
|
||||
|
public long getTaskCount() { |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
try { |
||||
|
long n = this.completedTaskCount; |
||||
|
Iterator var4 = this.workers.iterator(); |
||||
|
|
||||
|
while(var4.hasNext()) { |
||||
|
Worker w = (Worker)var4.next(); |
||||
|
n += w.completedTasks; |
||||
|
if (w.isLocked()) { |
||||
|
++n; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
long var9 = n + (long)this.workQueue.size(); |
||||
|
return var9; |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public long getCompletedTaskCount() { |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
try { |
||||
|
long n = this.completedTaskCount; |
||||
|
|
||||
|
Worker w; |
||||
|
for(Iterator var4 = this.workers.iterator(); var4.hasNext(); n += w.completedTasks) { |
||||
|
w = (Worker)var4.next(); |
||||
|
} |
||||
|
|
||||
|
long var9 = n; |
||||
|
return var9; |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public String toString() { |
||||
|
ReentrantLock mainLock = this.mainLock; |
||||
|
mainLock.lock(); |
||||
|
|
||||
|
long ncompleted; |
||||
|
int nworkers; |
||||
|
int nactive; |
||||
|
try { |
||||
|
ncompleted = this.completedTaskCount; |
||||
|
nactive = 0; |
||||
|
nworkers = this.workers.size(); |
||||
|
Iterator var6 = this.workers.iterator(); |
||||
|
|
||||
|
while(var6.hasNext()) { |
||||
|
Worker w = (Worker)var6.next(); |
||||
|
ncompleted += w.completedTasks; |
||||
|
if (w.isLocked()) { |
||||
|
++nactive; |
||||
|
} |
||||
|
} |
||||
|
} finally { |
||||
|
mainLock.unlock(); |
||||
|
} |
||||
|
|
||||
|
int c = this.ctl.get(); |
||||
|
String rs = runStateLessThan(c, 0) ? "Running" : (runStateAtLeast(c, 1610612736) ? "Terminated" : "Shutting down"); |
||||
|
return super.toString() + "[" + rs + ", pool size = " + nworkers + ", active threads = " + nactive + ", queued tasks = " + this.workQueue.size() + ", completed tasks = " + ncompleted + "]"; |
||||
|
} |
||||
|
|
||||
|
protected void beforeExecute(Thread t, Runnable r) { |
||||
|
} |
||||
|
|
||||
|
protected void afterExecute(Runnable r, Throwable t) { |
||||
|
} |
||||
|
|
||||
|
protected void terminated() { |
||||
|
} |
||||
|
|
||||
|
public static class DiscardOldestPolicy implements IncreasedRejectedExecutionHandler { |
||||
|
public DiscardOldestPolicy() { |
||||
|
} |
||||
|
|
||||
|
public void rejectedExecution(Runnable r, IncreasedThreadPoolExecutor e) { |
||||
|
if (!e.isShutdown()) { |
||||
|
e.getQueue().poll(); |
||||
|
e.execute(r); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public static class DiscardPolicy implements IncreasedRejectedExecutionHandler { |
||||
|
public DiscardPolicy() { |
||||
|
} |
||||
|
|
||||
|
public void rejectedExecution(Runnable r, IncreasedThreadPoolExecutor e) { |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public static class AbortPolicy implements IncreasedRejectedExecutionHandler { |
||||
|
public AbortPolicy() { |
||||
|
} |
||||
|
|
||||
|
public void rejectedExecution(Runnable r, IncreasedThreadPoolExecutor e) { |
||||
|
throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString()); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public static class CallerRunsPolicy implements IncreasedRejectedExecutionHandler { |
||||
|
public CallerRunsPolicy() { |
||||
|
} |
||||
|
|
||||
|
public void rejectedExecution(Runnable r, IncreasedThreadPoolExecutor e) { |
||||
|
if (!e.isShutdown()) { |
||||
|
r.run(); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private final class Worker extends AbstractQueuedSynchronizer implements Runnable { |
||||
|
private static final long serialVersionUID = 6138294804551838833L; |
||||
|
final Thread thread; |
||||
|
Runnable firstTask; |
||||
|
volatile long completedTasks; |
||||
|
|
||||
|
Worker(Runnable firstTask) { |
||||
|
this.setState(-1); |
||||
|
this.firstTask = firstTask; |
||||
|
this.thread = IncreasedThreadPoolExecutor.this.getThreadFactory().newThread(this); |
||||
|
} |
||||
|
|
||||
|
public void run() { |
||||
|
IncreasedThreadPoolExecutor.this.runWorker(this); |
||||
|
} |
||||
|
|
||||
|
protected boolean isHeldExclusively() { |
||||
|
return this.getState() != 0; |
||||
|
} |
||||
|
|
||||
|
protected boolean tryAcquire(int unused) { |
||||
|
if (this.compareAndSetState(0, 1)) { |
||||
|
this.setExclusiveOwnerThread(Thread.currentThread()); |
||||
|
return true; |
||||
|
} else { |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
protected boolean tryRelease(int unused) { |
||||
|
this.setExclusiveOwnerThread((Thread)null); |
||||
|
this.setState(0); |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
public void lock() { |
||||
|
this.acquire(1); |
||||
|
} |
||||
|
|
||||
|
public boolean tryLock() { |
||||
|
return this.tryAcquire(1); |
||||
|
} |
||||
|
|
||||
|
public void unlock() { |
||||
|
this.release(1); |
||||
|
} |
||||
|
|
||||
|
public boolean isLocked() { |
||||
|
return this.isHeldExclusively(); |
||||
|
} |
||||
|
|
||||
|
void interruptIfStarted() { |
||||
|
Thread t; |
||||
|
if (this.getState() >= 0 && (t = this.thread) != null && !t.isInterrupted()) { |
||||
|
try { |
||||
|
t.interrupt(); |
||||
|
} catch (SecurityException var3) { |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
@ -0,0 +1,71 @@ |
|||||
|
package org.nl.acs.opc; |
||||
|
|
||||
|
import java.util.concurrent.*; |
||||
|
|
||||
|
public class ThreadPoolUtl { |
||||
|
private static ExecutorService eventExecutorService = null; |
||||
|
private static ExecutorService cycleExecutorService = null; |
||||
|
|
||||
|
private ThreadPoolUtl() { |
||||
|
} |
||||
|
|
||||
|
public static ExecutorService getEventSingleInstanse() { |
||||
|
if (eventExecutorService == null) { |
||||
|
Class var0 = ThreadPoolUtl.class; |
||||
|
synchronized(ThreadPoolUtl.class) { |
||||
|
if (eventExecutorService == null) { |
||||
|
eventExecutorService = newIncreasedBlockedThreadPool(50, 200, 5); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return eventExecutorService; |
||||
|
} |
||||
|
|
||||
|
public static ExecutorService getCycleSingleInstanse() { |
||||
|
if (cycleExecutorService == null) { |
||||
|
Class var0 = ThreadPoolUtl.class; |
||||
|
synchronized(ThreadPoolUtl.class) { |
||||
|
if (cycleExecutorService == null) { |
||||
|
cycleExecutorService = newIncreasedBlockedThreadPool(5, 200, 5); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return cycleExecutorService; |
||||
|
} |
||||
|
|
||||
|
public static ExecutorService newIncreasedThreadPool() { |
||||
|
return newIncreasedThreadPool(50, 200, 5); |
||||
|
} |
||||
|
|
||||
|
public static ExecutorService newIncreasedBlockedThreadPool() { |
||||
|
return newIncreasedBlockedThreadPool(50, 200, 5); |
||||
|
} |
||||
|
|
||||
|
public static ExecutorService newIncreasedThreadPool(int corePoolSize, int maximumPoolSize, int multiple) { |
||||
|
return new IncreasedThreadPoolExecutor(corePoolSize, maximumPoolSize, multiple, 1L, TimeUnit.HOURS, new LinkedBlockingDeque(), new IncreasedBlokdedThreadPoolPolicy()); |
||||
|
} |
||||
|
|
||||
|
public static ExecutorService newIncreasedBlockedThreadPool(int corePoolSize, int maximumPoolSize, int multiple) { |
||||
|
int queueLength = maximumPoolSize * multiple; |
||||
|
return new IncreasedThreadPoolExecutor(corePoolSize, maximumPoolSize, multiple, 1L, TimeUnit.HOURS, new ArrayBlockingQueue(queueLength), new IncreasedBlokdedThreadPoolPolicy()); |
||||
|
} |
||||
|
|
||||
|
public static ExecutorService newBlockedThreadPool() { |
||||
|
return newBlockedThreadPool(50, 300, 200); |
||||
|
} |
||||
|
|
||||
|
public static ExecutorService newBlockedThreadPool(int coreNum, int maxNum, int cacheNum) { |
||||
|
return new ThreadPoolExecutor(coreNum, maxNum, 1L, TimeUnit.HOURS, new ArrayBlockingQueue(cacheNum), new BlockedThreadPoolPolicy()); |
||||
|
} |
||||
|
|
||||
|
public static ExecutorService newCachedThreadPool() { |
||||
|
return Executors.newCachedThreadPool(); |
||||
|
} |
||||
|
|
||||
|
public static ExecutorService newFixedThreadPool(int maxNum) { |
||||
|
return Executors.newFixedThreadPool(maxNum); |
||||
|
} |
||||
|
|
||||
|
} |
||||
Loading…
Reference in new issue