我一个线程管理设计

package com.ggjy.gd;

import java.util.HashMap;
import java.util.Map;

public class DothingsAction {

	public static void main(String[] args) {
		
		Map<String, Object> taskMap = new HashMap<String, Object>();
		
		taskMap.put("task1", "1");
		taskMap.put("task2", "2");
		taskMap.put("task3", "3");
		taskMap.put("task4", "4");
		taskMap.put("task5", "5");
		
		// 科研项目的申报,这个项目具体要做什么事情
		WorkTeamProcess workTeamProcess = new WorkTeamProcess(taskMap);
		
		// 国家科学院有一项重大科研项目(workteamThread),
		// 需要上报国家(remoteteam),
		// 国家把把科研项目提上日程(scheduleCoutainer)
		
		// 国家只要提上日程,<[这项科研项目就要启动了]> 或迟或早,就等经费足够
		// 由国家监控线程检索经费什么时候足够
		RemoteTeamService remote = new RemoteTeamService();
		remote.addWorkTeamProcess(workTeamProcess);
	}
}


package com.ggjy.gd;

public class RemoteTeamService {

	ScheduleContainer sic = null;
	
	public RemoteTeamService() {
		sic = ScheduleContainer.getInstance();
	}
	
	// 国家把上报来的科研项目提上日程
	public String addWorkTeamProcess(WorkTeamProcess workTeamProcess) {
		return sic.addWorkTeamProcess(workTeamProcess);
	}
}

package com.ggjy.gd;

import java.io.Serializable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

public class ScheduleContainer implements Serializable {

	private static final long serialVersionUID = 1L;

	private static ScheduleContainer schedule = null;
	
	private static ConcurrentHashMap<Object, Object>  totalMap = new ConcurrentHashMap<Object, Object>();
	
	private static ConcurrentHashMap<Object, Object>  importCounteMap = new ConcurrentHashMap<Object, Object>();
	
	// 多線程計數器
	private static AtomicInteger impExpTaskCount = new AtomicInteger(0);
	// private static Integer impExpTaskCount = new Integer(0);
	
	private int maxCounter = 0;
	
	private MyMonitor myMonitor = null;
	
	private static Object lock = new Object(); 
	
	public static ScheduleContainer getInstance()
	{
	
		synchronized (lock) {
			if (schedule == null)
			{
				schedule = new ScheduleContainer();
			}
			
			return schedule;
		}
	}
	
	// 国家提上日程的东西【经费足马上启动, 经费不足就等足够再启动】
	public synchronized String addWorkTeamProcess(WorkTeamProcess workTeamProcess)
	{
		String result = "RUN_NOW";
		
		// 反馈申报组要其启动项目
		WorkTeamThread workTeamThread = new WorkTeamThread(workTeamProcess);
		
		this.maxCounter = 10;
		
		if (this.maxCounter > impExpTaskCount.get())
		{
			new Thread(workTeamThread).start();
		}
		else
		{
			// 国家经费预算组,监控经费是否足够[国家限制每年最多十个重大科研项目]
			result = "QUEUR_WAIT";
			MyMonitor.setExportThreadList(workTeamThread);
			
			// 如果監控線程停止了 就重啟下
			if (this.myMonitor == null || (!this.myMonitor.isRunning()))
			{
				this.myMonitor = new MyMonitor();
				this.myMonitor.start();
			}
			
			return result;
		}
		
		return result;
	}

	public void setTotal(String currentTime, long total)
	{
		this.totalMap.put(currentTime, total);
	}
	
	public long getTotal(String currentTime) {
		Object total =  totalMap.get(currentTime);
		
		if (null == total) {return 0L;};
		
		return 0L;
	}
	
	public static AtomicInteger getImpExpTaskCount() {
		return impExpTaskCount;
	}

	public static void setImpExpTaskCount(AtomicInteger impExpTaskCount) {
		ScheduleContainer.impExpTaskCount = impExpTaskCount;
	}


	public static void incrementImpExpTaskCount()
	{
		impExpTaskCount.incrementAndGet();
	}
	
	public static void decrementImpExpTaskCount()
	{
		impExpTaskCount.decrementAndGet();
	}
	
}

package com.ggjy.gd;

import java.util.ArrayList;
import java.util.List;

/**
 * 線程監視器;同樣是一個線程類
 * @author AlDeric
 */
public class MyMonitor extends Thread {

	private static List<WorkTeamThread> exprotThreadList = new ArrayList<WorkTeamThread>();
	
	private boolean stop;
	
	public boolean isRunning()
	{
		return !this.stop;
	}
	
	public void run()
	{
		int maxCounte = 10;
		while (!exprotThreadList.isEmpty()) // 如果線程任務不為空,則拿一個執行
		{
			try {
				Thread.sleep(5000L);
				if (ScheduleContainer.getImpExpTaskCount().get() < maxCounte)
				{
					WorkTeamThread exportThread =  exprotThreadList.get(0);
					new Thread(exportThread).start(); // 啟動業務線程
					exprotThreadList.remove(0); // 從管理線程集合中拿掉一個業務線程
				}
			}catch(Exception e)
			{
				
			}
			
			this.stop = true;
		}
	}
	
	public static void setExportThreadList(WorkTeamThread exportThread)
	{
		exprotThreadList.add(exportThread); // 添加一個線程
	}
}


package com.ggjy.gd;

public class WorkTeamThread extends Thread{

	private WorkTeamProcess workTeamProcess = null;
	
	public WorkTeamThread(WorkTeamProcess workTeamProcess) {
		this.workTeamProcess = workTeamProcess;
	}

	// 经费下来了,通知科研组开工搞科研
	public void run()
	{
		try{
			ScheduleContainer.incrementImpExpTaskCount();
			this.workTeamProcess.startTask();
		}
		catch(Exception e)
		{
			
		}
		finally
		{
			ScheduleContainer.decrementImpExpTaskCount();
		}
	}
}


package com.ggjy.gd;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

/**
 * 業務類
 * @author AlDeric
 */
public class WorkTeamProcess implements Serializable{

	private static final long serialVersionUID = 1L;

	protected ScheduleContainer scheduleContainer = null;
	
	protected long taskCount;
	
	// 全局变量
	private Map<String, Object> taskMap = new HashMap<String, Object>();
	
	// 構造函數
	public WorkTeamProcess(Map<String, Object> taskMap)
	{
		this.taskMap = taskMap;
		this.scheduleContainer = ScheduleContainer.getInstance();
	}
	
	// 申报组获得经费,启动科研项目,下面的科研工作者开工啦
	public void startTask() {
		String exportType = String.valueOf(this.taskMap.get("task1"));
		
		if ("1".equals(exportType))
		{
			doBizMethod();
		}
	}

	// 具體要做的事情是什麼
	private void doBizMethod() {
		
		System.out.print("我只是一顆棋子,上面任務下來了,我要去做事了 ......");
	}
}