线程运用-抽象类使用

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

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


/**
 * 线程基本类
 * 
 * 记录线程开始时间/结束时间/ 线程名称/线程属性参数
 * @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;//开始时间

    private String threadName;//线程名字

    private Long endTime;//结束时间

    private Long removeDelay = 0l;//线程结束后多久移除管理,单位秒

    private volatile boolean isRun;//线程是否运行中

    /**
     * 只定义线程名，
     * 线程状态数据执行完成removeDelay秒后删除
     * @param threadName
     * @param removeDelay 小于等于0执行完后删除
     */
    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("开奖线程异常。");
            logger.error(e.getMessage(),e);
        } finally {
            logger.info("开奖线程状态数据移除。");
            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为唯一的标识
    public static Map<String, BaseThread> map = new HashMap<String, BaseThread>();

    /**
     * 执行线程，并把线程放入管理MAP中
     * 
     * @param thread
     * @create_time 2010-12-29 下午08:33:15
     */
    public static void excute(BaseThread thread) {
        map.put(thread.getThreadName(), thread);
        threadExec.execute(thread);

    }

    /**
     * 检查线程是否运行中 
     * @param threadName
     * @return T 是 F不是
     * @create_time 2010-12-29 下午08:55:13
     */
    public static boolean isExcute(String threadName) {
        BaseThread thread = map.get(threadName);
        if (thread == null) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * 删除线程数据
     * @param threadName
     * @create_time 2010-12-29 下午09:46:48
     */
    public static void removeThreadData(String threadName) {
        map.remove(threadName);
    }

    /**
     * 遍历移除超时线程数据
     * 
     * @create_time 2010-12-29 下午09:58:15
     */
    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;

/**
 * 派奖线程
 * 
 * @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);
        }
    }
}