任务线程轮空30次后自动销毁，降低低频任务的无效线程消耗。

doc/XXL-JOB官方文档.md

 - 3、XxlJobLogger的日志多参数支持；
 - 4、路由策略新增 "忙碌转移" 模式：按照顺序依次进行空闲检测，第一个空闲检测成功的机器选定为目标执行器并发起调度；
 - 5、路由策略代码重构；
+- 6、执行器重复注册问题修复；
+- 7、任务线程轮空30次后自动销毁，降低低频任务的无效线程消耗。
 
 #### TODO LIST
 - 1、任务权限管理：执行器为粒度分配权限，核心操作校验权限；
 - 6、任务依赖，流程图，子任务+会签任务，各节点日志；
 - 7、调度任务优先级；
 - 8、移除quartz依赖，重写调度模块：新增或恢复任务时将下次执行记录插入delayqueue，调度中心集群竞争分布式锁，成功节点批量加载到期delayqueue数据，批量执行。
-- 9、任务线程轮空30次后自动销毁，降低低频任务的无效线程消耗。
-- 10、注册界面，出现重复地址问题；
 
 
 ## 七、其他

xxl-job-admin/src/main/java/com/xxl/job/admin/core/thread/JobRegistryMonitorHelper.java

 								if (registryList == null) {
 									registryList = new ArrayList<String>();
 								}
-								registryList.add(item.getRegistryValue());
+								if (!registryList.contains(item.getRegistryValue())) {
+									registryList.add(item.getRegistryValue());
+								}
 								temp.put(groupKey, registryList);
 							}
 						}

xxl-job-core/src/main/java/com/xxl/job/core/executor/XxlJobExecutor.java

     // ---------------------------------- job thread repository
     private static ConcurrentHashMap<Integer, JobThread> JobThreadRepository = new ConcurrentHashMap<Integer, JobThread>();
     public static JobThread registJobThread(int jobId, IJobHandler handler, String removeOldReason){
-        JobThread newJobThread = new JobThread(handler);
+        JobThread newJobThread = new JobThread(jobId, handler);
         newJobThread.start();
         logger.info(">>>>>>>>>>> xxl-job regist JobThread success, jobId:{}, handler:{}", new Object[]{jobId, handler});
 

xxl-job-core/src/main/java/com/xxl/job/core/thread/JobThread.java

 import com.xxl.job.core.biz.model.HandleCallbackParam;
 import com.xxl.job.core.biz.model.ReturnT;
 import com.xxl.job.core.biz.model.TriggerParam;
+import com.xxl.job.core.executor.XxlJobExecutor;
 import com.xxl.job.core.handler.IJobHandler;
 import com.xxl.job.core.log.XxlJobFileAppender;
 import com.xxl.job.core.log.XxlJobLogger;
  */
 public class JobThread extends Thread{
 	private static Logger logger = LoggerFactory.getLogger(JobThread.class);
-	
+
+	private int jobId;
 	private IJobHandler handler;
 	private LinkedBlockingQueue<TriggerParam> triggerQueue;
 	private ConcurrentHashSet<Integer> triggerLogIdSet;		// avoid repeat trigger for the same TRIGGER_LOG_ID
 	private String stopReason;
 
     private boolean running = false;    // if running job
+	private int idleTimes = 0;			// idel times
 
 
-	public JobThread(IJobHandler handler) {
+	public JobThread(int jobId, IJobHandler handler) {
+		this.jobId = jobId;
 		this.handler = handler;
-		triggerQueue = new LinkedBlockingQueue<TriggerParam>();
-		triggerLogIdSet = new ConcurrentHashSet<Integer>();
+		this.triggerQueue = new LinkedBlockingQueue<TriggerParam>();
+		this.triggerLogIdSet = new ConcurrentHashSet<Integer>();
 	}
 	public IJobHandler getHandler() {
 		return handler;
 	public void run() {
 		while(!toStop){
 			running = false;
+			idleTimes++;
 			try {
 				// to check toStop signal, we need cycle, so wo cannot use queue.take(), instand of poll(timeout)
 				TriggerParam triggerParam = triggerQueue.poll(3L, TimeUnit.SECONDS);
 				if (triggerParam!=null) {
 					running = true;
+					idleTimes = 0;
 					triggerLogIdSet.remove(triggerParam.getLogId());
 					
 					// parse param
 
 						XxlJobLogger.log("<br>----------- JobThread Exception:" + errorMsg + "<br>----------- xxl-job job execute end(error) -----------");
 					}
-
-
-
 					
 					// callback handler info
 					if (!toStop) {
 						ReturnT<String> stopResult = new ReturnT<String>(ReturnT.FAIL_CODE, stopReason + " [业务运行中，被强制终止]");
 						TriggerCallbackThread.pushCallBack(new HandleCallbackParam(triggerParam.getLogId(), stopResult));
 					}
+				} else {
+					if (idleTimes > 3) {
+						XxlJobExecutor.removeJobThread(jobId, "excutor idel times over limit.");
+					}
 				}
-			} catch (Exception e) {
+			} catch (Throwable e) {
 				if (toStop) {
 					XxlJobLogger.log("<br>----------- xxl-job toStop, stopReason:" + stopReason);
 				}