之前的文章我介绍了C#版本的多线程和自定义线程处理器。
View Code
View Code
接下来我们来看看Java版本的呢
java 的线程和C#的线程有点区别，java的线程没有是否是后台线程一说，具体原因是java的线程是jvm的c++代码模拟线程，而C#的线程也是C++模拟线程。但是区别在于C#的线程会基于系统的线程。
C# 的 Thread.IsBackground;
这里唯一的区别在于，C#开启线程如果是非后台线程即便是你关闭了程序，如果不是强制退出进程的情况下。线程还会继续运行，知道垃圾回收机制强制回收。如果设置了后台线程标识，关闭程序就直接退出。
java没有一说。
java线程有分组和底层线程ID一说。C#没有。
java的线程可以自定义线程运行接口 Runnable 或者 重写线程run()方法。
其实这些都是大同小异的，区别性不大。
java线程的基础知识，到处都是，我不在BB
直接开始整体吧~！
1 /** 2 * 线程模型 3 * 4 * @author 失足程序员 5 * @Blog http://www.cnblogs.com/ty408/ 6 * @mail 492794628@qq.com 7 * @phone 13882122019 8 * 9 */ 10 public class ThreadModel extends Thread { 11 12 private static final Logger log = Logger.getLogger(TaskModel.class); 13 private static int threadID = 0; 14 private static final Object SYN_OBJECT = new Object(); 15 private long tid; 16 /** 17 * 任务列表 线程安全的任务列表 18 */ 19 protected final List<TaskModel> taskQueue = Collections.synchronizedList(new LinkedList<TaskModel>()); 20 //false标识删除线程 21 private boolean runing = true; 22 23 public ThreadModel(ThreadGroup group) { 24 this(group, "无名"); 25 } 26 27 public ThreadModel(ThreadGroup group, String name) { 28 super(group, name); 29 synchronized (SYN_OBJECT) { 30 threadID++; 31 tid = threadID; 32 } 33 } 34 35 @Override 36 public long getId() { 37 return this.tid; 38 } 39 40 /** 41 * 增加新的任务 每增加一个新任务，都要唤醒任务队列 42 * 43 * @param runnable 44 */ 45 public void addTask(TaskModel runnable) { 46 synchronized (taskQueue) { 47 taskQueue.add(runnable); 48 /* 唤醒队列, 开始执行 */ 49 taskQueue.notify(); 50 } 51 } 52 53 public void setRuning(boolean runing) { 54 this.runing = runing; 55 } 56 57 @Override 58 public void run() { 59 while (runing && ThreadManager.getInstance().isRunning()) { 60 TaskModel r = null; 61 while (taskQueue.isEmpty() && runing && ThreadManager.getInstance().isRunning()) { 62 try { 63 /* 任务队列为空，则等待有新任务加入从而被唤醒 */ 64 synchronized (taskQueue) { 65 taskQueue.wait(500); 66 } 67 } catch (InterruptedException ie) { 68 log.error(ie); 69 } 70 } 71 synchronized (taskQueue) { 72 /* 取出任务执行 */ 73 if (runing && ThreadManager.getInstance().isRunning()) { 74 r = taskQueue.remove(0); 75 } 76 } 77 if (r != null) { 78 /* 执行任务 */ 79 //r.setSubmitTimeL(); 80 long submitTime = System.currentTimeMillis(); 81 try { 82 r.run(); 83 } catch (Exception e) { 84 log.error("工人<“" + Thread.currentThread().getName() + "”> 执行任务<" + r.getID() + "(“" + r.getName() + "”)> 遇到错误: " + e); 85 e.printStackTrace(); 86 } 87 long timeL1 = System.currentTimeMillis() - submitTime; 88 long timeL2 = System.currentTimeMillis() - r.getSubmitTime(); 89 if (timeL1 <= 100L) { 90 log.info("工人<“" + Thread.currentThread().getName() + "”> 完成了任务：" + r.toString() + " 执行耗时：" + timeL1 + " 提交耗时：" + timeL2); 91 } else if (timeL1 <= 1000L) { 92 log.info("工人<“" + Thread.currentThread().getName() + "”> 长时间执行 完成任务：" + r.toString() + " “考虑”任务脚本逻辑 耗时：" + timeL1 + " 提交耗时：" + timeL2); 93 } else if (timeL1 <= 4000L) { 94 log.info("工人<“" + Thread.currentThread().getName() + "”> 超长时间执行完成 任务：" + r.toString() + " “检查”任务脚本逻辑 耗时：" + timeL1 + " 提交耗时：" + timeL2); 95 } else { 96 log.info("工人<“" + Thread.currentThread().getName() + "”> 超长时间执行完成 任务：" + r.toString() + " “考虑是否应该删除”任务脚本 耗时：" + timeL1 + " 提交耗时：" + timeL2); 97 } 98 r = null; 99 } 100 } 101 log.error("线程结束, 工人<“" + Thread.currentThread().getName() + "”>退出"); 102 } 103 104 @Override 105 public String toString() { 106 return "Thread{" + "tid=" + tid + ",Name=" + this.getName() + '}'; 107 } 108 109 }
这里创建我们自定义的线程模型，有两点值得注意的是，
protected final List<TaskModel> taskQueue = Collections.synchronizedList(new LinkedList<TaskModel>());
synchronized (taskQueue) { taskQueue.add(runnable); /* 唤醒队列, 开始执行 */ taskQueue.notify(); } synchronized (taskQueue) { taskQueue.wait(500); }
这里我们同样没有使用Thread.Sleep();对线程进行暂停，同样使用的是 taskQueue.wait();来进行线程暂停，这是因为当任务队列为空的时候，需要暂停线程。
当新的任务被放进来的时候，又必须立即开始执行任务。
为了防止线程永久暂停，设置的是500毫秒，这样我们需要关闭程序（ThreadManager.getInstance().isRunning()==false）停止线程时候他会自定停止。
辅助键值对存储器
1 /** 2 * 辅助键值对存储 3 * 4 * @author 失足程序员 5 * @Blog http://www.cnblogs.com/ty408/ 6 * @mail 492794628@qq.com 7 * @phone 13882122019 8 */ 9 public class ObjectAttribute extends HashMap<String, Object> { 10 11 private static final long serialVersionUID = -5320260807959251398L; 12 13 /** 14 * 调用此方法 删除值是需要保证存在key值和value值 否则空指针报错 15 * 16 * @param <T> 17 * @param key 18 * @param clazz 19 * @return 20 * @deprecated 需要保证存在key值和value值 否则空指针报错 慎重 21 */ 22 @Deprecated 23 public <T extends Object> T remove(String key, Class<T> clazz) { 24 Object obj = this.remove(key); 25 return (T) obj; 26 } 27 28 /** 29 * 如果未找到也返回 null 30 * 31 * @param key 32 * @return 33 */ 34 public String getStringValue(String key) { 35 if (this.containsKey(key)) { 36 return this.get(key).toString(); 37 } 38 return null; 39 } 40 41 /** 42 * 如果未找到也返回 0 43 * 44 * @param key 45 * @return 46 */ 47 public int getintValue(String key) { 48 if (this.containsKey(key)) { 49 return (int) (this.get(key)); 50 } 51 return 0; 52 } 53 54 /** 55 * 如果未找到也返回 null 56 * 57 * @param key 58 * @return 59 */ 60 public Integer getIntegerValue(String key) { 61 if (this.containsKey(key)) { 62 return (Integer) (this.get(key)); 63 } 64 return null; 65 } 66 67 /** 68 * 如果未找到也返回 0 69 * 70 * @param key 71 * @return 72 */ 73 public long getlongValue(String key) { 74 if (this.containsKey(key)) { 75 return (long) (this.get(key)); 76 } 77 return 0; 78 } 79 80 /** 81 * 如果未找到也返回 null 82 * 83 * @param key 84 * @return 85 */ 86 public Long getLongValue(String key) { 87 if (this.containsKey(key)) { 88 return (Long) (this.get(key)); 89 } 90 return null; 91 } 92 93 /** 94 * 如果未找到也返回 0 95 * 96 * @param key 97 * @return 98 */ 99 public float getfloatValue(String key) { 100 if (this.containsKey(key)) { 101 return (float) (this.get(key)); 102 } 103 return 0; 104 } 105 106 /** 107 * 如果未找到也返回 null 108 * 109 * @param key 110 * @return 111 */ 112 public Float getFloatValue(String key) { 113 if (this.containsKey(key)) { 114 return (Float) (this.get(key)); 115 } 116 return null; 117 } 118 119 /** 120 * 如果未找到也返回 false 121 * 122 * @param key 123 * @return 124 */ 125 public boolean getbooleanValue(String key) { 126 if (this.containsKey(key)) { 127 return (boolean) (this.get(key)); 128 } 129 return false; 130 } 131 132 /** 133 * 如果未找到也返回 null 134 * 135 * @param key 136 * @return 137 */ 138 public Boolean getBooleanValue(String key) { 139 if (this.containsKey(key)) { 140 return (Boolean) (this.get(key)); 141 } 142 return null; 143 } 144 145 @Override 146 public Object clone() { 147 return super.clone(); //To change body of generated methods, choose Tools | Templates. 148 } 149 }
任务执行模型
1 /** 2 * 任务模型 3 * 4 * @author 失足程序员 5 * @Blog http://www.cnblogs.com/ty408/ 6 * @mail 492794628@qq.com 7 * @phone 13882122019 8 * 9 */ 10 public abstract class TaskModel { 11 12 private static final Logger log = Logger.getLogger(TaskModel.class); 13 14 private long ID; 15 private String Name; 16 //运行时数据 17 private ObjectAttribute runAttribute = new ObjectAttribute(); 18 19 public TaskModel(long ID, String Name) { 20 this.ID = ID; 21 this.Name = Name; 22 this.runAttribute.put("submitTime", System.currentTimeMillis()); 23 } 24 25 public TaskModel() { 26 this(0, "无名"); 27 } 28 29 public long getSubmitTime() { 30 return this.runAttribute.getlongValue("submitTime"); 31 } 32 33 public ObjectAttribute getRunAttribute() { 34 return runAttribute; 35 } 36 37 public void setRunAttribute(ObjectAttribute runAttribute) { 38 this.runAttribute = runAttribute; 39 } 40 41 public long getID() { 42 return ID; 43 } 44 45 public String getName() { 46 return Name; 47 } 48 49 public abstract void run(); 50 51 @Override 52 public String toString() { 53 return "TaskModel{" + "ID=" + ID + ", Name=" + Name + ", runAttribute=" + runAttribute + '}'; 54 } 55 56 }
接下来我们测试一下
1 ThreadModel threadModel = new ThreadModel(new ThreadGroup("Test"), "Test"); 2 threadModel.start(); 3 threadModel.addTask(new TaskModel() { 4 5 @Override 6 public void run() { 7 System.out.println("TaskModel Test"); 8 } 9 });
执行结果
TaskModel Test
[04-24 17:31:26:0223:INFO : sz.network.threadpool.TaskModel:97 行] -> 工人<“Test”> 完成了任务：TaskModel{ID=0, Name=无名, runAttribute={submitTime=1429867886219}} 执行耗时：0 提交耗时：4
我们看到居然有提交耗时，，别奇怪，，因为在某些情况下，线程的从暂停状态到唤醒状态需要消耗时间的，系统不可能有那么多空闲资源，收到你的命令马上就放弃一切事情执行你的命令。
我们调试运行时可以看见当前程序所有线程，以及分组情况（我使用的是NetBeans IDE 8.0.2 开发工具）
接下来我们来构建一下。后台线程池，
1 /** 2 * 后台线程池 3 * 4 * @author 失足程序员 5 * @Blog http://www.cnblogs.com/ty408/ 6 * @mail 492794628@qq.com 7 * @phone 13882122019 8 */ 9 class BackThread { 10 11 private static final Logger log = Logger.getLogger(BackThread.class); 12 13 private final ThreadGroup threadGroup = new ThreadGroup(ThreadManager.getGlobeThreadGroup(), "后台执行器"); 14 15 /* 任务列表 */ 16 private final List<TaskModel> taskQueue = Collections.synchronizedList(new LinkedList<TaskModel>()); 17 private final BackThreadRunnable backThreadRunnable = new BackThreadRunnable(); 18 19 public BackThread() { 20 int threadcountI = 10; 21 for (int i = 1; i <= threadcountI; i++) { 22 Thread thread = new Thread(threadGroup, backThreadRunnable, "后台线程-" + i); 23 thread.start(); 24 } 25 log.info("---初始化后台线程池--线程数量:" + threadcountI + "------------"); 26 } 27 28 /** 29 * 增加新的任务 每增加一个新任务，都要唤醒任务队列 30 * 31 * @param newTask 32 */ 33 public void addTask(TaskModel newTask) { 34 synchronized (taskQueue) { 35 taskQueue.add(newTask); 36 /* 唤醒队列, 开始执行 */ 37 taskQueue.notify(); 38 } 39 } 40 41 final class BackThreadRunnable implements Runnable { 42 43 /** 44 * 循环执行任务 45 */ 46 @Override 47 public void run() { 48 while (ThreadManager.getInstance().isRunning()) { 49 TaskModel r = null; 50 synchronized (taskQueue) { 51 while (taskQueue.isEmpty() && ThreadManager.getInstance().isRunning()) { 52 try { 53 /* 任务队列为空，则等待有新任务加入从而被唤醒 */ 54 taskQueue.wait(500); 55 } catch (InterruptedException ie) { 56 log.error(ie); 57 } 58 } 59 /* 取出任务执行 */ 60 if (ThreadManager.getInstance().isRunning()) { 61 r = taskQueue.remove(0); 62 } 63 } 64 if (r != null) { 65 /* 执行任务 */ 66 //r.setSubmitTimeL(); 67 long submitTime = System.currentTimeMillis(); 68 try { 69 r.run(); 70 } catch (Exception e) { 71 e.printStackTrace(); 72 log.error("工人<“" + Thread.currentThread().getName() + "”> 执行任务<" + r.getID() + "(“" + r.getName() + "”)> 遇到错误: " + e); 73 } 74 long timeL1 = System.currentTimeMillis() - submitTime; 75 long timeL2 = System.currentTimeMillis() - r.getSubmitTime(); 76 if (timeL1 <= 100L) { 77 log.info("工人<“" + Thread.currentThread().getName() + "”> 完成了任务：" + r.toString() + " 执行耗时：" + timeL1 + " 提交耗时：" + timeL2); 78 } else if (timeL1 <= 1000L) { 79 log.info("工人<“" + Thread.currentThread().getName() + "”> 长时间执行 完成任务：" + r.toString() + " “考虑”任务脚本逻辑 耗时：" + timeL1 + " 提交耗时：" + timeL2); 80 } else if (timeL1 <= 4000L) { 81 log.info("工人<“" + Thread.currentThread().getName() + "”> 超长时间执行完成 任务：" + r.toString() + " “检查”任务脚本逻辑 耗时：" + timeL1 + " 提交耗时：" + timeL2); 82 } else { 83 log.info("工人<“" + Thread.currentThread().getName() + "”> 超长时间执行完成 任务：" + r.toString() + " “考虑是否应该删除”任务脚本 耗时：" + timeL1 + " 提交耗时：" + timeL2); 84 } 85 r = null; 86 } 87 } 88 log.error("线程结束, 工人<“" + Thread.currentThread().getName() + "”>退出"); 89 } 90 } 91 }
以及定时器线程处理器
1 /** 2 * 定时器线程 3 * 4 * @author 失足程序员 5 * @Blog http://www.cnblogs.com/ty408/ 6 * @mail 492794628@qq.com 7 * @phone 13882122019 8 */ 9 class TimerThread extends ThreadModel { 10 11 private static final Logger log = Logger.getLogger(TimerThread.class); 12 13 public TimerThread() { 14 super(ThreadManager.getGlobeThreadGroup(), "全局定时器线程"); 15 this.start(); 16 } 17 18 @Override 19 public void run() { 20 while (ThreadManager.getInstance().isRunning()) { 21 while (ThreadManager.getInstance().isRunning() && taskQueue.isEmpty()) { 22 try { 23 /* 任务队列为空，则等待有新任务加入从而被唤醒 */ 24 synchronized (taskQueue) { 25 taskQueue.wait(200); 26 } 27 } catch (InterruptedException ie) { 28 } 29 } 30 ArrayList<TaskModel> taskModels; 31 synchronized (taskQueue) { 32 //队列不为空的情况下 取出队列定时器任务 33 taskModels = new ArrayList<>(taskQueue); 34 } 35 if (!taskModels.isEmpty()) { 36 for (TaskModel task : taskModels) { 37 TimerTask timerEvent = (TimerTask) task; 38 int execCount = timerEvent.getRunAttribute().getintValue("Execcount"); 39 long lastTime = timerEvent.getRunAttribute().getlongValue("LastExecTime"); 40 long nowTime = System.currentTimeMillis(); 41 if (nowTime > timerEvent.getStartTime() //是否满足开始时间 42 && (nowTime - timerEvent.getSubmitTime() > timerEvent.getIntervalTime())//提交以后是否满足了间隔时间 43 && (timerEvent.getEndTime() <= 0 || nowTime < timerEvent.getEndTime()) //判断结束时间 44 && (nowTime - lastTime >= timerEvent.getIntervalTime())) //判断上次执行到目前是否满足间隔时间 45 { 46 //提交执行 47 ThreadManager.getInstance().addTask(timerEvent.gettID(), timerEvent); 48 //记录 49 execCount++; 50 timerEvent.getRunAttribute().put("Execcount", execCount); 51 timerEvent.getRunAttribute().put("LastExecTime", nowTime); 52 } 53 nowTime = System.currentTimeMillis(); 54 //判断删除条件 55 if ((timerEvent.getEndTime() > 0 && nowTime < timerEvent.getEndTime()) 56 || (timerEvent.getActionCount() > 0 && timerEvent.getActionCount() <= execCount)) { 57 taskQueue.remove(task); 58 } 59 } 60 } 61 try { 62 //定时器， 执行方式 间隔 4ms 执行一次 把需要处理的任务放到对应的处理线程 63 Thread.sleep(4); 64 } catch (InterruptedException ex) { 65 } 66 } 67 log.error("线程结束, 工人<“" + Thread.currentThread().getName() + "”>退出"); 68 } 69 70 @Override 71 public void addTask(TaskModel task) { 72 if (((TimerTask) task).isIsStartAction()) { 73 try { 74 task.run(); 75 } catch (Exception e) { 76 log.error("工人<“" + Thread.currentThread().getName() + "”> 执行任务<" + task.getID() + "(“" + task.getName() + "”)> 遇到错误: " + e); 77 e.printStackTrace(); 78 } 79 } 80 super.addTask(task); 81 } 82 }
定时器线程执行任务模型
1 /** 2 * 定时器执行器 3 * 4 * @author 失足程序员 5 * @Blog http://www.cnblogs.com/ty408/ 6 * @mail 492794628@qq.com 7 * @phone 13882122019 8 */ 9 public abstract class TimerTask extends TaskModel { 10 11 private static final long serialVersionUID = -8331296295264699207L; 12 13 /** 14 * 线程ID 15 */ 16 private long tID; 17 /** 18 * 开始执行的时间 19 */ 20 private long startTime; 21 22 /** 23 * 是否一开始执行一次 24 */ 25 private boolean isStartAction; 26 27 /** 28 * 结束时间 29 */ 30 private long endTime; 31 32 /** 33 * 执行次数 34 */ 35 private int actionCount; 36 37 /** 38 * 间隔执行时间 39 */ 40 private int intervalTime; 41 42 /** 43 * 44 * @param tID 指定执行线程 45 * @param startTime 指定开始时间 46 * @param isStartAction 是否一开始就执行一次 47 * @param endTime 指定结束时间 48 * @param actionCount 指定执行次数 49 * @param intervalTime 指定间隔时间 50 * @param ID 51 * @param Name 52 */ 53 public TimerTask(long tID, long startTime, boolean isStartAction, long endTime, int actionCount, int intervalTime, long ID, String Name) { 54 super(ID, Name); 55 this.tID = tID; 56 this.startTime = startTime; 57 this.isStartAction = isStartAction; 58 this.endTime = endTime; 59 this.actionCount = actionCount; 60 this.intervalTime = intervalTime; 61 } 62 63 /** 64 * 指定任务的开始执行时间 65 * 66 * @param tID 指定执行线程 67 * @param startTime 指定开始时间 68 * @param isStartAction 是否一开始就执行一次 69 * @param actionCount 指定执行次数 70 * @param intervalTime 指定间隔时间 71 * @param ID 72 * @param Name 73 */ 74 public TimerTask(long tID, long startTime, boolean isStartAction, int actionCount, int intervalTime, long ID, String Name) { 75 this(tID, startTime, isStartAction, 0, actionCount, intervalTime, ID, Name); 76 } 77 78 /** 79 * 指定结束时间已结束时间为准，执行次数不一定够 80 * 81 * @param tID 指定执行线程 82 * @param isStartAction 是否一开始就执行一次 83 * @param endTime 指定结束时间 84 * @param actionCount 指定执行次数 85 * @param intervalTime 指定间隔时间 86 * @param ID 87 * @param Name 88 */ 89 public TimerTask(long tID, boolean isStartAction, long endTime, int actionCount, int intervalTime, long ID, String Name) { 90 this(tID, 0, isStartAction, endTime, actionCount, intervalTime, ID, Name); 91 } 92 93 /** 94 * 指定开始时间，和结束时间 95 * 96 * @param tID 指定执行线程 97 * @param startTime 指定开始时间 98 * @param endTime 指定结束时间 99 * @param intervalTime 指定间隔时间 100 * @param ID 101 * @param Name 102 */ 103 public TimerTask(long tID, long startTime, long endTime, int intervalTime, long ID, String Name) { 104 this(tID, startTime, false, endTime, -1, intervalTime, ID, Name); 105 } 106 107 /** 108 * 指定执行线程，指定执行次数，指定间隔时间 109 * 110 * @param tID 指定执行线程 111 * @param actionCount 指定执行次数 112 * @param intervalTime 指定间隔时间 113 * @param ID 114 * @param Name 115 */ 116 public TimerTask(long tID, int actionCount, int intervalTime, long ID, String Name) { 117 this(tID, 0, false, 0, actionCount, intervalTime, ID, Name); 118 } 119 120 /** 121 * 指定的执行次数和间隔时间 122 * 123 * @param actionCount 指定执行次数 124 * @param intervalTime 指定间隔时间 125 */ 126 public TimerTask(int actionCount, int intervalTime) { 127 this(0, 0, false, 0, actionCount, intervalTime, 0, "无名"); 128 } 129 130 /** 131 * 提交后指定的时间以后执行一次 132 * 133 * @param intervalTime 指定间隔时间 134 */ 135 public TimerTask(int intervalTime) { 136 this(0, 0, false, 0, 1, intervalTime, 0, "无名"); 137 } 138 139 public long gettID() { 140 return tID; 141 } 142 143 public void settID(long tID) { 144 this.tID = tID; 145 } 146 147 public long getStartTime() { 148 return startTime; 149 } 150 151 public void setStartTime(long startTime) { 152 this.startTime = startTime; 153 } 154 155 public boolean isIsStartAction() { 156 return isStartAction; 157 } 158 159 public void setIsStartAction(boolean isStartAction) { 160 this.isStartAction = isStartAction; 161 } 162 163 public long getEndTime() { 164 return endTime; 165 } 166 167 public void setEndTime(long endTime) { 168 this.endTime = endTime; 169 } 170 171 public int getActionCount() { 172 return actionCount; 173 } 174 175 public void setActionCount(int actionCount) { 176 this.actionCount = actionCount; 177 } 178 179 public int getIntervalTime() { 180 return intervalTime; 181 } 182 183 public void setIntervalTime(int intervalTime) { 184 this.intervalTime = intervalTime; 185 } 186 187 }
创建一个线程管理器
1 /** 2 * 线程管理器 3 * 4 * @author 失足程序员 5 * @Blog http://www.cnblogs.com/ty408/ 6 * @mail 492794628@qq.com 7 * @phone 13882122019 8 * 9 */ 10 public class ThreadManager { 11 12 private static final Logger log = Logger.getLogger(ThreadManager.class); 13 14 private static final ThreadGroup GlobeThreadGroup = new ThreadGroup("全局线程"); 15 private static final ThreadGroup lsThreadGroup = new ThreadGroup("零时线程"); 16 17 private static ThreadManager instance = new ThreadManager(); 18 19 private static final HashMap<Long, ThreadModel> workThreadMaps = new HashMap<>(0); 20 21 public static ThreadManager getInstance() { 22 return instance; 23 } 24 25 public static ThreadGroup getGlobeThreadGroup() { 26 return GlobeThreadGroup; 27 } 28 29 private final BackThread backThread = new BackThread(); 30 31 private final TimerThread timerThread = new TimerThread(); 32 33 //服务器是否运行状态标识 34 private boolean running = true; 35 36 public boolean isRunning() { 37 return running; 38 } 39 40 public void StopServer() { 41 running = false; 42 } 43 44 public long addThread(ThreadModel thread) { 45 workThreadMaps.put(thread.getId(), thread); 46 thread.start(); 47 return thread.getId(); 48 } 49 50 public long getThread(ThreadGroup threadGroup, String workName) { 51 return addThread(new ThreadModel(threadGroup, workName)); 52 } 53 54 public long getThread(String workName) { 55 return addThread(new ThreadModel(lsThreadGroup, workName)); 56 } 57 58 public boolean delete(long threadID) { 59 ThreadModel get = workThreadMaps.remove(threadID); 60 if (get != null) { 61 get.setRuning(false); 62 return true; 63 } 64 return false; 65 } 66 67 public void addTask(long threadID, TaskModel task) { 68 if (workThreadMaps.containsKey(threadID)) { 69 workThreadMaps.get(threadID).addTask(task); 70 } else { 71 addBackTask(task); 72 } 73 } 74 75 public void addTimerTask(TimerTask task) { 76 timerThread.addTask(task); 77 } 78 79 /** 80 * 81 * @param task 82 */ 83 public void addBackTask(TaskModel task) { 84 backThread.addTask(task); 85 } 86 87 }
重新测试一下
1 public static void main(String[] args) { 2 3 long thread = ThreadManager.getInstance().getThread("Test"); 4 ThreadManager.getInstance().addBackTask(new TaskModel() { 5 6 @Override 7 public void run() { 8 System.out.println("addBackTask"); 9 } 10 }); 11 ThreadManager.getInstance().addTimerTask(new TimerTask(5, 100) { 12 13 @Override 14 public void run() { 15 System.out.println("TimerTask 5 100"); 16 } 17 }); 18 ThreadManager.getInstance().addTask(thread, new TaskModel() { 19 20 @Override 21 public void run() { 22 System.out.println("Thread test"); 23 } 24 }); 25 }
1 [04-24 17:40:23:0883:INFO : sz.network.threadpool.BackThread:37 行] -> ---初始化后台线程池--线程数量:10------------ 2 addBackTask 3 Thread test 4 [04-24 17:40:23:0888:INFO : sz.network.threadpool.BackThread:89 行] -> 工人<“后台线程-10”> 完成了任务：TaskModel{ID=0, Name=无名, runAttribute={submitTime=1429868423887}} 执行耗时：0 提交耗时：0 5 [04-24 17:40:23:0888:INFO : sz.network.threadpool.TaskModel:97 行] -> 工人<“Test”> 完成了任务：TaskModel{ID=0, Name=无名, runAttribute={submitTime=1429868423887}} 执行耗时：1 提交耗时：1 6 TimerTask 5 100 7 [04-24 17:40:23:0988:INFO : sz.network.threadpool.BackThread:89 行] -> 工人<“后台线程-9”> 完成了任务：TaskModel{ID=0, Name=无名, runAttribute={LastExecTime=1429868423988, submitTime=1429868423887, Execcount=1}} 执行耗时：0 提交耗时：101 8 TimerTask 5 100 9 [04-24 17:40:24:0088:INFO : sz.network.threadpool.BackThread:89 行] -> 工人<“后台线程-8”> 完成了任务：TaskModel{ID=0, Name=无名, runAttribute={LastExecTime=1429868424088, submitTime=1429868423887, Execcount=2}} 执行耗时：0 提交耗时：201 10 TimerTask 5 100 11 [04-24 17:40:24:0189:INFO : sz.network.threadpool.BackThread:89 行] -> 工人<“后台线程-7”> 完成了任务：TaskModel{ID=0, Name=无名, runAttribute={LastExecTime=1429868424189, submitTime=1429868423887, Execcount=3}} 执行耗时：0 提交耗时：302 12 TimerTask 5 100 13 [04-24 17:40:24:0289:INFO : sz.network.threadpool.BackThread:89 行] -> 工人<“后台线程-6”> 完成了任务：TaskModel{ID=0, Name=无名, runAttribute={LastExecTime=1429868424289, submitTime=1429868423887, Execcount=4}} 执行耗时：0 提交耗时：402 14 TimerTask 5 100 15 [04-24 17:40:24:0389:INFO : sz.network.threadpool.BackThread:89 行] -> 工人<“后台线程-9”> 完成了任务：TaskModel{ID=0, Name=无名, runAttribute={LastExecTime=1429868424389, submitTime=1429868423887, Execcount=5}} 执行耗时：0 提交耗时：502
调试查看线程信息
Java版本的自定义线程处理器就算完成了。
功能和实现基本和C#版本一样。
扫一扫
720
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
