在前：之前使用SpringMVC，现在有项目使用Jfinal。

现在的项目对多线程这块使用的比较多，所以线程池就需要一些考虑。SpringMVC中有TaskExecutor，想着根据这个思路给Jfinal来个插件。因为之前没有写过插件，所以可能考虑的不周。我先本地测试了下，线程池的管理没有测出比较大的问题。

    之前@JFinal 有提过，一般的线程池在使用tomcat或者Jetty管理。

有需要的可以试试，新鲜出炉，没有特别的测试。

链接: https://pan.baidu.com/s/1eSx87p4 密码: zvvn

1.再AppConf.java中使用的configPlugin()

TaskPlugin taskPlugin = new TaskPlugin();
me.add(taskPlugin);

2.使用的话，这样使用：

TaskKit.taskExecutor.execute(new Runnable() {
@Override
public void run() {
 //println();
}
});

3.配置文件中配置：

task.core_pool_size=200
task.max_pool_size=10000
task.queue_capacity=500
task.keep_alive_seconds=30000

4.TaskPlugin的大体代码：

 
	private boolean isStarted = false;
	
	private JfinalTaskExecutor jfinalTaskExecutor;
	
	@Override
	public boolean start() {
		if (isStarted)
			return true;
		jfinalTaskExecutor = new JfinalTaskExecutor();
		
		jfinalTaskExecutor.setCorePoolSize(PropKit.getInt("task.core_pool_size"));
		jfinalTaskExecutor.setKeepAliveSeconds(PropKit.getInt("task.keep_alive_seconds"));
		jfinalTaskExecutor.setQueueCapacity(PropKit.getInt("task.queue_capacity"));
		jfinalTaskExecutor.setMaxPoolSize( PropKit.getInt("task.max_pool_size"));
		jfinalTaskExecutor.afterPropertiesSet();
		
		TaskKit.setTaskExecutor(jfinalTaskExecutor);
		isStarted = true;
		return true;
	}
 
	
	@Override
	public boolean stop() {
		jfinalTaskExecutor.shutdown();
		isStarted = false;
		return true;
	}

补充-----------------------

5.重要的JfinalTaskExecutor类

/**
 * @Title: TaskExecutor.java
 * @Package com.jfinal.plugin
 * @Description: TODO
 * Copyright: Copyright (c) 2016 
 * Company:QDUM
 * 
 * @author qdum-ivy
 * @date 2016年9月13日 上午10:36:42
 * @version V1.0
 */
 
package com.jfinal.plugin.task.support;
 
import java.io.Serializable;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
 
import javax.management.RuntimeErrorException;
 
import com.jfinal.plugin.IPlugin;
 
 
/**
  * @ClassName: TaskExecutor
  * @Description: TODO
  * @author qdum-ivy
  * @date 2016年9月13日 上午10:36:42
  *
  */
 
public class JfinalTaskExecutor extends ExecutorConfigurationSupport implements SchedulingTaskExecutor, Serializable {
	
 
	private static final long serialVersionUID = 8691977770206223903L;
 
	private final Object poolSizeMonitor = new Object();
 
	private int corePoolSize = 1;
 
	private int maxPoolSize = Integer.MAX_VALUE;
 
	private int keepAliveSeconds = 60;
 
	private boolean allowCoreThreadTimeOut = false;
 
	private int queueCapacity = Integer.MAX_VALUE;
 
	private ThreadPoolExecutor threadPoolExecutor;
 
 
	public void setCorePoolSize(int corePoolSize) {
		synchronized (this.poolSizeMonitor) {
			this.corePoolSize = corePoolSize;
			if (this.threadPoolExecutor != null) {
				this.threadPoolExecutor.setCorePoolSize(corePoolSize);
			}
		}
	}
 
	public int getCorePoolSize() {
		synchronized (this.poolSizeMonitor) {
			return this.corePoolSize;
		}
	}
 
	public void setMaxPoolSize(int maxPoolSize) {
		synchronized (this.poolSizeMonitor) {
			this.maxPoolSize = maxPoolSize;
			if (this.threadPoolExecutor != null) {
				this.threadPoolExecutor.setMaximumPoolSize(maxPoolSize);
			}
		}
	}
 
	public int getMaxPoolSize() {
		synchronized (this.poolSizeMonitor) {
			return this.maxPoolSize;
		}
	}
 
	public void setKeepAliveSeconds(int keepAliveSeconds) {
		synchronized (this.poolSizeMonitor) {
			this.keepAliveSeconds = keepAliveSeconds;
			if (this.threadPoolExecutor != null) {
				this.threadPoolExecutor.setKeepAliveTime(keepAliveSeconds, TimeUnit.SECONDS);
			}
		}
	}
 
	public int getKeepAliveSeconds() {
		synchronized (this.poolSizeMonitor) {
			return this.keepAliveSeconds;
		}
	}
 
	public void setAllowCoreThreadTimeOut(boolean allowCoreThreadTimeOut) {
		this.allowCoreThreadTimeOut = allowCoreThreadTimeOut;
	}
 
	public void setQueueCapacity(int queueCapacity) {
		this.queueCapacity = queueCapacity;
	}
 
 
	protected ExecutorService initializeExecutor(
			ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) {
 
		BlockingQueue<Runnable> queue = createQueue(this.queueCapacity);
		ThreadPoolExecutor executor  = new ThreadPoolExecutor(
				this.corePoolSize, this.maxPoolSize, this.keepAliveSeconds, TimeUnit.SECONDS,
				queue, threadFactory, rejectedExecutionHandler);
		if (this.allowCoreThreadTimeOut) {
			executor.allowCoreThreadTimeOut(true);
		}
 
		this.threadPoolExecutor = executor;
		return executor;
	}
 
	protected BlockingQueue<Runnable> createQueue(int queueCapacity) {
		if (queueCapacity > 0) {
			return new LinkedBlockingQueue<Runnable>(queueCapacity);
		}
		else {
			return new SynchronousQueue<Runnable>();
		}
	}
 
	public ThreadPoolExecutor getThreadPoolExecutor() throws IllegalStateException {
		if (threadPoolExecutor==null) {
			new RuntimeException("threadPoolExecutor == null");
		}
		return this.threadPoolExecutor;
	}
 
	public int getPoolSize() {
		return getThreadPoolExecutor().getPoolSize();
	}
 
	public int getActiveCount() {
		return getThreadPoolExecutor().getActiveCount();
	}
 
 
	public void execute(Runnable task) {
		Executor executor = getThreadPoolExecutor();
		try {
			executor.execute(task);
		}
		catch (RuntimeErrorException ex) {
			throw new RuntimeException("execute error "+ex);
		}
	}
 
	public void execute(Runnable task, long startTimeout) {
		execute(task);
	}
 
	public Future<?> submit(Runnable task) {
		ExecutorService executor = getThreadPoolExecutor();
		try {
			return executor.submit(task);
		}
		catch (RejectedExecutionException ex) {
			throw new RuntimeException("execute error "+ex);
		}
	}
 
	public <T> Future<T> submit(Callable<T> task) {
		ExecutorService executor = getThreadPoolExecutor();
		try {
			return executor.submit(task);
		}
		catch (RejectedExecutionException ex) {
			throw new RuntimeException("execute error "+ex);
		}
	}
 
	public boolean prefersShortLivedTasks() {
		return true;
	}
 
}

6.父类：ExecutorConfigurationSupport.java

import java.util.concurrent.ExecutorService;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
 
@SuppressWarnings("serial")
public abstract class ExecutorConfigurationSupport extends CustomizableThreadFactory{
 
	protected final Log logger = LogFactory.getLog(getClass());
 
	private ThreadFactory threadFactory = this;
 
	private boolean threadNamePrefixSet = false;
 
	private RejectedExecutionHandler rejectedExecutionHandler = new ThreadPoolExecutor.AbortPolicy();
 
	private boolean waitForTasksToCompleteOnShutdown = false;
 
	private int awaitTerminationSeconds = 0;
 
	private String beanName;
 
	private ExecutorService executor;
 
	public void setThreadFactory(ThreadFactory threadFactory) {
		this.threadFactory = (threadFactory != null ? threadFactory : this);
	}
 
	@Override
	public void setThreadNamePrefix(String threadNamePrefix) {
		super.setThreadNamePrefix(threadNamePrefix);
		this.threadNamePrefixSet = true;
	}
	public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) {
		this.rejectedExecutionHandler =
				(rejectedExecutionHandler != null ? rejectedExecutionHandler : new ThreadPoolExecutor.AbortPolicy());
	}
	public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) {
		this.waitForTasksToCompleteOnShutdown = waitForJobsToCompleteOnShutdown;
	}
 
	public void setAwaitTerminationSeconds(int awaitTerminationSeconds) {
		this.awaitTerminationSeconds = awaitTerminationSeconds;
	}
 
	public void setBeanName(String name) {
		this.beanName = name;
	}
 
 
	/**
	 * Calls {@code initialize()} after the container applied all property values.
	 * @see #initialize()
	 */
	public void afterPropertiesSet() {
		initialize();
	}
 
	/**
	 * Set up the ExecutorService.
	 */
	public void initialize() {
		if (logger.isInfoEnabled()) {
			logger.info("Initializing ExecutorService " + (this.beanName != null ? " '" + this.beanName + "'" : ""));
		}
		if (!this.threadNamePrefixSet && this.beanName != null) {
			setThreadNamePrefix(this.beanName + "-");
		}
		this.executor = initializeExecutor(this.threadFactory, this.rejectedExecutionHandler);
	}
 
	protected abstract ExecutorService initializeExecutor(
			ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler);
 
 
	public void destroy() {
		shutdown();
	}
 
	public void shutdown() {
		if (logger.isInfoEnabled()) {
			logger.info("Shutting down ExecutorService" + (this.beanName != null ? " '" + this.beanName + "'" : ""));
		}
		if (this.waitForTasksToCompleteOnShutdown) {
			this.executor.shutdown();
		}
		else {
			this.executor.shutdownNow();
		}
		awaitTerminationIfNecessary();
	}
	private void awaitTerminationIfNecessary() {
		if (this.awaitTerminationSeconds > 0) {
			try {
				if (!this.executor.awaitTermination(this.awaitTerminationSeconds, TimeUnit.SECONDS)) {
					if (logger.isWarnEnabled()) {
						logger.warn("Timed out while waiting for executor" +
								(this.beanName != null ? " '" + this.beanName + "'" : "") + " to terminate");
					}
				}
			}
			catch (InterruptedException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Interrupted while waiting for executor" +
							(this.beanName != null ? " '" + this.beanName + "'" : "") + " to terminate");
				}
				Thread.currentThread().interrupt();
			}
		}
	}
 
}

这两个类大体管理了生命周期。另外还有一些类四五个类代码太多，等找时间整理下一块打包发出来。