@Override protected final void beforeExecute(Thread t, Runnable r) { super.beforeExecute(t, r); queueSize.decrementAndGet(); }
public void execute(Runnable command) { if (running) { if (workQueue.offer(command)) { onTaskQueued(command); return; } onTaskQueueOverflow(); return; } throw new RejectedExecutionException("ThreadPool is not running"); }
/** * Must hold statelock while calling this method. * @param wt */ private void doStartWorker() { startWorker(new BasicWorker()); expectedWorkerCount++; }
@Override public final void setMaximumPoolSize(int maximumPoolSize) { if (maximumPoolSize < 1) { throw new IllegalStateException("maximumPoolSize < 1"); } synchronized (statelock) { if (running) { this.maxPoolSize = maximumPoolSize; int toAdd = maximumPoolSize - expectedWorkerCount; while (toAdd > 0) { toAdd--; doStartWorker(); } while (toAdd++ < 0) { workQueue.add(poison); expectedWorkerCount--; } super.onMaxNumberOfThreadsReached(); } } }
@Override protected void onTaskQueueOverflow() { queueSize.decrementAndGet(); super.onTaskQueueOverflow(); }
@Override public String toString() { return super.toString()+ ", min-threads="+getCorePoolSize()+ ", max-threads="+getMaximumPoolSize(); } }
protected final void setImpl(ThreadPoolConfig cfg) { if (cfg == null) { throw new IllegalArgumentException("config is null"); } cfg = cfg.copy(); final Queue<Runnable> queue = cfg.getQueue(); if ((queue == null || queue instanceof BlockingQueue) && (cfg.getCorePoolSize() < 0 || cfg.getCorePoolSize() == cfg.getMaxPoolSize())) { this.pool = cfg.getQueueLimit() < 0 ? new FixedThreadPool(cfg.getPoolName(), cfg.getMaxPoolSize(), (BlockingQueue<Runnable>) queue, cfg.getThreadFactory(), cfg.getMonitoringProbe()) : new QueueLimitedThreadPool( cfg.getPoolName(), cfg.getMaxPoolSize(), cfg.getQueueLimit(), cfg.getThreadFactory(), (BlockingQueue<Runnable>) queue, cfg.getMonitoringProbe()); } else { this.pool = new SyncThreadPool(cfg.getPoolName(), cfg.getCorePoolSize(), cfg.getMaxPoolSize(), cfg.getKeepAliveTime(TimeUnit.MILLISECONDS), TimeUnit.MILLISECONDS, cfg.getThreadFactory(), queue, cfg.getQueueLimit(),cfg.getMonitoringProbe()); } this.config = cfg.updateFrom(pool); }
/** * * @param name * @param poolsize * @param workQueue * @param threadfactory * @param probe */ public FixedThreadPool(String name, int poolsize, BlockingQueue<Runnable> workQueue, ThreadFactory threadfactory, ThreadPoolMonitoringProbe probe) { super(probe, name, threadfactory,poolsize); this.workQueue = workQueue != null ? workQueue : DataStructures.getLTQinstance(Runnable.class); synchronized (statelock) { while (poolsize-- > 0) { doStartWorker(); } } super.onMaxNumberOfThreadsReached(); }