Thread usage - abstract class usage

package com.xxx.betcart.server.service.impl.threadmanager;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * Thread base class
 *
 * Record thread start time/end time/thread name/thread attribute parameters
 * @project commonsTiger
 * @author alanpeng
 * @date 2011-1-7
 * Copyright (C) 2010-2012 www.2caipiao.com Inc. All rights reserved.
 */
public abstract class BaseThread implements Runnable {
    private transient final Logger logger = LoggerFactory.getLogger(BaseThread.class);
    
    private Long startTime;//Start time

    private String threadName;//Thread name

    private Long endTime;//End time

    private Long removeDelay = 0l;//How long to remove management after the thread ends, in seconds

    private volatile boolean isRun;//Whether the thread is running

    /**
     * only define the thread name,
     * Thread state data is deleted after removeDelay seconds after the execution of thread state data is completed
     * @param threadName
     * @param removeDelay is less than or equal to 0 to delete after execution
     */
    public BaseThread(String threadName, Long removeDelay) {
        this.threadName = threadName;
        this.removeDelay = removeDelay;
    }

    @Override
    public void run() {
       
        try {
            startTime = System.currentTimeMillis();
            excuteTask();
            endTime = System.currentTimeMillis();
        } catch (Exception e) {
            logger.error("The lottery thread is abnormal.");
            logger.error(e.getMessage(),e);
        } finally {
            logger.info("Lottery thread status data removed.");
            ThreadManage.removeThreadData(threadName);

        }
        
    }

    public abstract void excuteTask();

    public Long getStartTime() {
        return startTime;
    }

    public void setStartTime(Long startTime) {
        this.startTime = startTime;
    }

    public String getThreadName() {
        return threadName;
    }

    public void setThreadName(String threadName) {
        this.threadName = threadName;
    }

    public Long getEndTime() {
        return endTime;
    }

    public void setEndTime(Long endTime) {
        this.endTime = endTime;
    }

    public Long getRemoveDelay() {
        return removeDelay;
    }

    public void setRemoveDelay(Long removeDelay) {
        this.removeDelay = removeDelay;
    }

    public boolean isRun() {
        return isRun;
    }

    public void setRun(boolean isRun) {
        this.isRun = isRun;
    }

}

package com.xxx.betcart.server.service.impl.threadmanager;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ScheduledThreadPoolExecutor;


public class ThreadManage {

    public static ScheduledThreadPoolExecutor threadExec = new ScheduledThreadPoolExecutor(50);

    //key is a unique identifier
    public static Map<String, BaseThread> map = new HashMap<String, BaseThread>();

    /**
     * Execute the thread and put the thread into the management MAP
     *
     * @param thread
     * @create_time 2010-12-29 8:33:15 PM
     */
    public static void excute(BaseThread thread) {
        map.put(thread.getThreadName(), thread);
        threadExec.execute(thread);

    }

    /**
     * Check if the thread is running
     * @param threadName
     * @return T is F or not
     * @create_time 2010-12-29 8:55:13 PM
     */
    public static boolean isExcute(String threadName) {
        BaseThread thread = map.get(threadName);
        if (thread == null) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * delete thread data
     * @param threadName
     * @create_time 2010-12-29 09:46:48 PM
     */
    public static void removeThreadData(String threadName) {
        map.remove(threadName);
    }

    /**
     * Traverse to remove timeout thread data
     *
     * @create_time 2010-12-29 09:58:15 PM
     */
    public static void removeThreadDataTimeOut() {
        for (String name : map.keySet()) {
            BaseThread thread = map.get(name);
            if (thread.getEndTime() != null && thread.getRemoveDelay() > 0) {
                if (System.currentTimeMillis() > (thread.getEndTime() + thread.getRemoveDelay())) {
                    removeThreadData(name);
                }
            }
        }
    }

    public static void main(String[] args) throws Exception {
   
    }
}

package com.xxx.betcart.server.service.impl.threadmanager.thread;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.xxx.betcart.common.service.BetPlanPackageService;
import com.xxx.betcart.server.service.impl.threadmanager.BaseThread;

/**
 * Reward thread
 *
 * @project admin
 * @author alanpeng
 * @date 2011-6-2
 * Copyright (C) 2010-2012 www.2caipiao.com Inc. All rights reserved.
 */
public class SychronizedPrizeThread extends BaseThread {

    private transient final Logger logger = LoggerFactory.getLogger(SychronizedPrizeThread.class);

    private long packageId;
    private BetPlanPackageService betPlanPackageService;

	public SychronizedPrizeThread(String threadName,
			long packageId, BetPlanPackageService betPlanPackageService) {
		super(threadName,0l);
		this.packageId = packageId;
		this.betPlanPackageService = betPlanPackageService;
	}
	public void excuteTask() {
        try {
            setRun(true);
            Thread.currentThread().setName(this.getThreadName());
            betPlanPackageService.synchronousPrizeByPackageId(packageId);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            setRun (false);
        }
    }
}