Java 多线程 自定义线程辅助
之前的文章我介绍了C#版本的多线程和自定义线程处理器。
接下来我们来看看Java版本的呢
java 的线程和C#的线程有点区别，java的线程没有是否是后台线程一说，具体原因是java的线程是jvm的c++代码模拟线程，而C#的线程也是C++模拟线程。但是区别在于C#的线程会基于系统的线程。
C# 的 Thread.IsBackground;
这里唯一的区别在于，C#开启线程如果是非后台线程即便是你关闭了程序，如果不是强制退出进程的情况下。线程还会继续运行，知道垃圾回收机制强制回收。如果设置了后台线程标识，关闭程序就直接退出。
java没有一说。
java线程有分组和底层线程ID一说。C#没有。
java的线程可以自定义线程运行接口 Runnable 或者 重写线程run()方法。
其实这些都是大同小异的，区别性不大。
java线程的基础知识，到处都是，我不在BB
直接开始整体吧~！
/**
* 线程模型
*
* @author 失足程序员
* @Blog http://www.cnblogs.com/ty408/
* @mail 492794628@qq.com
* @phone 13882122019
*
*/
public class ThreadModel extends Thread {
private static final Logger log = Logger.getLogger(TaskModel.class);
private static int threadID = 0;
private static final Object SYN_OBJECT = new Object();
private long tid;
/**
* 任务列表 线程安全的任务列表
*/
protected final List<TaskModel> taskQueue = Collections.synchronizedList(new LinkedList<TaskModel>());
//false标识删除线程
private boolean runing = true;
public ThreadModel(ThreadGroup group) {
this(group, "无名");
}
public ThreadModel(ThreadGroup group, String name) {
super(group, name);
synchronized (SYN_OBJECT) {
threadID++;
tid = threadID;
}
}
@Override
public long getId() {
return this.tid;
}
/**
* 增加新的任务 每增加一个新任务，都要唤醒任务队列
*
* @param runnable
*/
public void addTask(TaskModel runnable) {
synchronized (taskQueue) {
taskQueue.add(runnable);
/* 唤醒队列, 开始执行 */
taskQueue.notify();
}
}
public void setRuning(boolean runing) {
this.runing = runing;
}
@Override
public void run() {
while (runing && ThreadManager.getInstance().isRunning()) {
TaskModel r = null;
while (taskQueue.isEmpty() && runing && ThreadManager.getInstance().isRunning()) {
try {
/* 任务队列为空，则等待有新任务加入从而被唤醒 */
synchronized (taskQueue) {
taskQueue.wait(500);
}
} catch (InterruptedException ie) {
log.error(ie);
}
}
synchronized (taskQueue) {
/* 取出任务执行 */
if (runing && ThreadManager.getInstance().isRunning()) {
r = taskQueue.remove(0);
}
}
if (r != null) {
/* 执行任务 */
//r.setSubmitTimeL();
long submitTime = System.currentTimeMillis();
try {
r.run();
} catch (Exception e) {
log.error("工人<“" + Thread.currentThread().getName() + "”> 执行任务<" + r.getID() + "(“" + r.getName() + "”)> 遇到错误: " + e);
e.printStackTrace();
}
long timeL1 = System.currentTimeMillis() - submitTime;
long timeL2 = System.currentTimeMillis() - r.getSubmitTime();
if (timeL1 <= 100L) {
log.info("工人<“" + Thread.currentThread().getName() + "”> 完成了任务：" + r.toString() + " 执行耗时：" + timeL1 + " 提交耗时：" + timeL2);
} else if (timeL1 <= 1000L) {
log.info("工人<“" + Thread.currentThread().getName() + "”> 长时间执行 完成任务：" + r.toString() + " “考虑”任务脚本逻辑 耗时：" + timeL1 + " 提交耗时：" + timeL2);
} else if (timeL1 <= 4000L) {
log.info("工人<“" + Thread.currentThread().getName() + "”> 超长时间执行完成 任务：" + r.toString() + " “检查”任务脚本逻辑 耗时：" + timeL1 + " 提交耗时：" + timeL2);
} else {
log.info("工人<“" + Thread.currentThread().getName() + "”> 超长时间执行完成 任务：" + r.toString() + " “考虑是否应该删除”任务脚本 耗时：" + timeL1 + " 提交耗时：" + timeL2);
}
r = null;
}
}
log.error("线程结束, 工人<“" + Thread.currentThread().getName() + "”>退出");
}
@Override
public String toString() {
return "Thread{" + "tid=" + tid + ",Name=" + this.getName() + '}';
}
}
这里创建我们自定义的线程模型，有两点值得注意的是，
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）停止线程时候他会自定停止。
辅助键值对存储器
/**
* 辅助键值对存储
*
* @author 失足程序员
* @Blog http://www.cnblogs.com/ty408/
* @mail 492794628@qq.com
* @phone 13882122019
*/
public class ObjectAttribute extends HashMap<String, Object> {
private static final long serialVersionUID = -5320260807959251398L;
/**
* 调用此方法 删除值是需要保证存在key值和value值 否则空指针报错
*
* @param <T>
* @param key
* @param clazz
* @return
* @deprecated 需要保证存在key值和value值 否则空指针报错 慎重
*/
@Deprecated
public <T extends Object> T remove(String key, Class<T> clazz) {
Object obj = this.remove(key);
return (T) obj;
}
/**
* 如果未找到也返回 null
*
* @param key
* @return
*/
public String getStringValue(String key) {
if (this.containsKey(key)) {
return this.get(key).toString();
}
return null;
}
/**
* 如果未找到也返回 0
*
* @param key
* @return
*/
public int getintValue(String key) {
if (this.containsKey(key)) {
return (int) (this.get(key));
}
return 0;
}
/**
* 如果未找到也返回 null
*
* @param key
* @return
*/
public Integer getIntegerValue(String key) {
if (this.containsKey(key)) {
return (Integer) (this.get(key));
}
return null;
}
/**
* 如果未找到也返回 0
*
* @param key
* @return
*/
public long getlongValue(String key) {
if (this.containsKey(key)) {
return (long) (this.get(key));
}
return 0;
}
/**
* 如果未找到也返回 null
*
* @param key
* @return
*/
public Long getLongValue(String key) {
if (this.containsKey(key)) {
return (Long) (this.get(key));
}
return null;
}
/**
* 如果未找到也返回 0
*
* @param key
* @return
*/
public float getfloatValue(String key) {
if (this.containsKey(key)) {
return (float) (this.get(key));
}
return 0;
}
/**
* 如果未找到也返回 null
*
* @param key
* @return
*/
public Float getFloatValue(String key) {
if (this.containsKey(key)) {
return (Float) (this.get(key));
}
return null;
}
/**
* 如果未找到也返回 false
*
* @param key
* @return
*/
public boolean getbooleanValue(String key) {
if (this.containsKey(key)) {
return (boolean) (this.get(key));
}
return false;
}
/**
* 如果未找到也返回 null
*
* @param key
* @return
*/
public Boolean getBooleanValue(String key) {
if (this.containsKey(key)) {
return (Boolean) (this.get(key));
}
return null;
}
@Override
public Object clone() {
return super.clone(); //To change body of generated methods, choose Tools | Templates.
}
}
任务执行模型
/**
* 任务模型
*
* @author 失足程序员
* @Blog http://www.cnblogs.com/ty408/
* @mail 492794628@qq.com
* @phone 13882122019
*
*/
public abstract class TaskModel {
private static final Logger log = Logger.getLogger(TaskModel.class);
private long ID;
private String Name;
//运行时数据
private ObjectAttribute runAttribute = new ObjectAttribute();
public TaskModel(long ID, String Name) {
this.ID = ID;
this.Name = Name;
this.runAttribute.put("submitTime", System.currentTimeMillis());
}
public TaskModel() {
this(0, "无名");
}
public long getSubmitTime() {
return this.runAttribute.getlongValue("submitTime");
}
public ObjectAttribute getRunAttribute() {
return runAttribute;
}
public void setRunAttribute(ObjectAttribute runAttribute) {
this.runAttribute = runAttribute;
}
public long getID() {
return ID;
}
public String getName() {
return Name;
}
public abstract void run();
@Override
public String toString() {
return "TaskModel{" + "ID=" + ID + ", Name=" + Name + ", runAttribute=" + runAttribute + '}';
}
}
接下来我们测试一下
ThreadModel threadModel = new ThreadModel(new ThreadGroup("Test"), "Test");
threadModel.start();
threadModel.addTask(new TaskModel() {
@Override
public void run() {
System.out.println("TaskModel Test");
}
});
执行结果
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 开发工具）
接下来我们来构建一下。后台线程池，
/**
* 后台线程池
*
* @author 失足程序员
* @Blog http://www.cnblogs.com/ty408/
* @mail 492794628@qq.com
* @phone 13882122019
*/
class BackThread {
private static final Logger log = Logger.getLogger(BackThread.class);
private final ThreadGroup threadGroup = new ThreadGroup(ThreadManager.getGlobeThreadGroup(), "后台执行器");
/* 任务列表 */
private final List<TaskModel> taskQueue = Collections.synchronizedList(new LinkedList<TaskModel>());
private final BackThreadRunnable backThreadRunnable = new BackThreadRunnable();
public BackThread() {
int threadcountI = 10;
for (int i = 1; i <= threadcountI; i++) {
Thread thread = new Thread(threadGroup, backThreadRunnable, "后台线程-" + i);
thread.start();
}
log.info("---初始化后台线程池--线程数量:" + threadcountI + "------------");
}
/**
* 增加新的任务 每增加一个新任务，都要唤醒任务队列
*
* @param newTask
*/
public void addTask(TaskModel newTask) {
synchronized (taskQueue) {
taskQueue.add(newTask);
/* 唤醒队列, 开始执行 */
taskQueue.notify();
}
}
final class BackThreadRunnable implements Runnable {
/**
* 循环执行任务
*/
@Override
public void run() {
while (ThreadManager.getInstance().isRunning()) {
TaskModel r = null;
synchronized (taskQueue) {
while (taskQueue.isEmpty() && ThreadManager.getInstance().isRunning()) {
try {
/* 任务队列为空，则等待有新任务加入从而被唤醒 */
taskQueue.wait(500);
} catch (InterruptedException ie) {
log.error(ie);
}
}
/* 取出任务执行 */
if (ThreadManager.getInstance().isRunning()) {
r = taskQueue.remove(0);
}
}
if (r != null) {
/* 执行任务 */
//r.setSubmitTimeL();
long submitTime = System.currentTimeMillis();
try {
r.run();
} catch (Exception e) {
e.printStackTrace();
log.error("工人<“" + Thread.currentThread().getName() + "”> 执行任务<" + r.getID() + "(“" + r.getName() + "”)> 遇到错误: " + e);
}
long timeL1 = System.currentTimeMillis() - submitTime;
long timeL2 = System.currentTimeMillis() - r.getSubmitTime();
if (timeL1 <= 100L) {
log.info("工人<“" + Thread.currentThread().getName() + "”> 完成了任务：" + r.toString() + " 执行耗时：" + timeL1 + " 提交耗时：" + timeL2);
} else if (timeL1 <= 1000L) {
log.info("工人<“" + Thread.currentThread().getName() + "”> 长时间执行 完成任务：" + r.toString() + " “考虑”任务脚本逻辑 耗时：" + timeL1 + " 提交耗时：" + timeL2);
} else if (timeL1 <= 4000L) {
log.info("工人<“" + Thread.currentThread().getName() + "”> 超长时间执行完成 任务：" + r.toString() + " “检查”任务脚本逻辑 耗时：" + timeL1 + " 提交耗时：" + timeL2);
} else {
log.info("工人<“" + Thread.currentThread().getName() + "”> 超长时间执行完成 任务：" + r.toString() + " “考虑是否应该删除”任务脚本 耗时：" + timeL1 + " 提交耗时：" + timeL2);
}
r = null;
}
}
log.error("线程结束, 工人<“" + Thread.currentThread().getName() + "”>退出");
}
}
}
以及定时器线程处理器
/**
* 定时器线程
*
* @author 失足程序员
* @Blog http://www.cnblogs.com/ty408/
* @mail 492794628@qq.com
* @phone 13882122019
*/
class TimerThread extends ThreadModel {
private static final Logger log = Logger.getLogger(TimerThread.class);
public TimerThread() {
super(ThreadManager.getGlobeThreadGroup(), "全局定时器线程");
this.start();
}
@Override
public void run() {
while (ThreadManager.getInstance().isRunning()) {
while (ThreadManager.getInstance().isRunning() && taskQueue.isEmpty()) {
try {
/* 任务队列为空，则等待有新任务加入从而被唤醒 */
synchronized (taskQueue) {
taskQueue.wait(200);
}
} catch (InterruptedException ie) {
}
}
ArrayList<TaskModel> taskModels;
synchronized (taskQueue) {
//队列不为空的情况下 取出队列定时器任务
taskModels = new ArrayList<>(taskQueue);
}
if (!taskModels.isEmpty()) {
for (TaskModel task : taskModels) {
TimerTask timerEvent = (TimerTask) task;
int execCount = timerEvent.getRunAttribute().getintValue("Execcount");
long lastTime = timerEvent.getRunAttribute().getlongValue("LastExecTime");
long nowTime = System.currentTimeMillis();
if (nowTime > timerEvent.getStartTime() //是否满足开始时间
&& (nowTime - timerEvent.getSubmitTime() > timerEvent.getIntervalTime())//提交以后是否满足了间隔时间
&& (timerEvent.getEndTime() <= 0 || nowTime < timerEvent.getEndTime()) //判断结束时间
&& (nowTime - lastTime >= timerEvent.getIntervalTime())) //判断上次执行到目前是否满足间隔时间
{
//提交执行
ThreadManager.getInstance().addTask(timerEvent.gettID(), timerEvent);
//记录
execCount++;
timerEvent.getRunAttribute().put("Execcount", execCount);
timerEvent.getRunAttribute().put("LastExecTime", nowTime);
}
nowTime = System.currentTimeMillis();
//判断删除条件
if ((timerEvent.getEndTime() > 0 && nowTime < timerEvent.getEndTime())
|| (timerEvent.getActionCount() > 0 && timerEvent.getActionCount() <= execCount)) {
taskQueue.remove(task);
}
}
}
try {
//定时器， 执行方式 间隔 4ms 执行一次 把需要处理的任务放到对应的处理线程
Thread.sleep(4);
} catch (InterruptedException ex) {
}
}
log.error("线程结束, 工人<“" + Thread.currentThread().getName() + "”>退出");
}
@Override
public void addTask(TaskModel task) {
if (((TimerTask) task).isIsStartAction()) {
try {
task.run();
} catch (Exception e) {
log.error("工人<“" + Thread.currentThread().getName() + "”> 执行任务<" + task.getID() + "(“" + task.getName() + "”)> 遇到错误: " + e);
e.printStackTrace();
}
}
super.addTask(task);
}
}
定时器线程执行任务模型
/**
* 定时器执行器
*
* @author 失足程序员
* @Blog http://www.cnblogs.com/ty408/
* @mail 492794628@qq.com
* @phone 13882122019
*/
public abstract class TimerTask extends TaskModel {
private static final long serialVersionUID = -8331296295264699207L;
/**
* 线程ID
*/
private long tID;
/**
* 开始执行的时间
*/
private long startTime;
/**
* 是否一开始执行一次
*/
private boolean isStartAction;
/**
* 结束时间
*/
private long endTime;
/**
* 执行次数
*/
private int actionCount;
/**
* 间隔执行时间
*/
private int intervalTime;
/**
*
* @param tID 指定执行线程
* @param startTime 指定开始时间
* @param isStartAction 是否一开始就执行一次
* @param endTime 指定结束时间
* @param actionCount 指定执行次数
* @param intervalTime 指定间隔时间
* @param ID
* @param Name
*/
public TimerTask(long tID, long startTime, boolean isStartAction, long endTime, int actionCount, int intervalTime, long ID, String Name) {
super(ID, Name);
this.tID = tID;
this.startTime = startTime;
this.isStartAction = isStartAction;
this.endTime = endTime;
this.actionCount = actionCount;
this.intervalTime = intervalTime;
}
/**
* 指定任务的开始执行时间
*
* @param tID 指定执行线程
* @param startTime 指定开始时间
* @param isStartAction 是否一开始就执行一次
* @param actionCount 指定执行次数
* @param intervalTime 指定间隔时间
* @param ID
* @param Name
*/
public TimerTask(long tID, long startTime, boolean isStartAction, int actionCount, int intervalTime, long ID, String Name) {
this(tID, startTime, isStartAction, 0, actionCount, intervalTime, ID, Name);
}
/**
* 指定结束时间已结束时间为准，执行次数不一定够
*
* @param tID 指定执行线程
* @param isStartAction 是否一开始就执行一次
* @param endTime 指定结束时间
* @param actionCount 指定执行次数
* @param intervalTime 指定间隔时间
* @param ID
* @param Name
*/
public TimerTask(long tID, boolean isStartAction, long endTime, int actionCount, int intervalTime, long ID, String Name) {
this(tID, 0, isStartAction, endTime, actionCount, intervalTime, ID, Name);
}
/**
* 指定开始时间，和结束时间
*
* @param tID 指定执行线程
* @param startTime 指定开始时间
* @param endTime 指定结束时间
* @param intervalTime 指定间隔时间
* @param ID
* @param Name
*/
public TimerTask(long tID, long startTime, long endTime, int intervalTime, long ID, String Name) {
this(tID, startTime, false, endTime, -1, intervalTime, ID, Name);
}
/**
* 指定执行线程，指定执行次数，指定间隔时间
*
* @param tID 指定执行线程
* @param actionCount 指定执行次数
* @param intervalTime 指定间隔时间
* @param ID
* @param Name
*/
public TimerTask(long tID, int actionCount, int intervalTime, long ID, String Name) {
this(tID, 0, false, 0, actionCount, intervalTime, ID, Name);
}
/**
* 指定的执行次数和间隔时间
*
* @param actionCount 指定执行次数
* @param intervalTime 指定间隔时间
*/
public TimerTask(int actionCount, int intervalTime) {
this(0, 0, false, 0, actionCount, intervalTime, 0, "无名");
}
/**
* 提交后指定的时间以后执行一次
*
* @param intervalTime 指定间隔时间
*/
public TimerTask(int intervalTime) {
this(0, 0, false, 0, 1, intervalTime, 0, "无名");
}
public long gettID() {
return tID;
}
public void settID(long tID) {
this.tID = tID;
}
public long getStartTime() {
return startTime;
}
public void setStartTime(long startTime) {
this.startTime = startTime;
}
public boolean isIsStartAction() {
return isStartAction;
}
public void setIsStartAction(boolean isStartAction) {
this.isStartAction = isStartAction;
}
public long getEndTime() {
return endTime;
}
public void setEndTime(long endTime) {
this.endTime = endTime;
}
public int getActionCount() {
return actionCount;
}
public void setActionCount(int actionCount) {
this.actionCount = actionCount;
}
public int getIntervalTime() {
return intervalTime;
}
public void setIntervalTime(int intervalTime) {
this.intervalTime = intervalTime;
}
}
创建一个线程管理器
/**
* 线程管理器
*
* @author 失足程序员
* @Blog http://www.cnblogs.com/ty408/
* @mail 492794628@qq.com
* @phone 13882122019
*
*/
public class ThreadManager {
private static final Logger log = Logger.getLogger(ThreadManager.class);
private static final ThreadGroup GlobeThreadGroup = new ThreadGroup("全局线程");
private static final ThreadGroup lsThreadGroup = new ThreadGroup("零时线程");
private static ThreadManager instance = new ThreadManager();
private static final HashMap<Long, ThreadModel> workThreadMaps = new HashMap<>(0);
public static ThreadManager getInstance() {
return instance;
}
public static ThreadGroup getGlobeThreadGroup() {
return GlobeThreadGroup;
}
private final BackThread backThread = new BackThread();
private final TimerThread timerThread = new TimerThread();
//服务器是否运行状态标识
private boolean running = true;
public boolean isRunning() {
return running;
}
public void StopServer() {
running = false;
}
public long addThread(ThreadModel thread) {
workThreadMaps.put(thread.getId(), thread);
thread.start();
return thread.getId();
}
public long getThread(ThreadGroup threadGroup, String workName) {
return addThread(new ThreadModel(threadGroup, workName));
}
public long getThread(String workName) {
return addThread(new ThreadModel(lsThreadGroup, workName));
}
public boolean delete(long threadID) {
ThreadModel get = workThreadMaps.remove(threadID);
if (get != null) {
get.setRuning(false);
return true;
}
return false;
}
public void addTask(long threadID, TaskModel task) {
if (workThreadMaps.containsKey(threadID)) {
workThreadMaps.get(threadID).addTask(task);
} else {
addBackTask(task);
}
}
public void addTimerTask(TimerTask task) {
timerThread.addTask(task);
}
/**
*
* @param task
*/
public void addBackTask(TaskModel task) {
backThread.addTask(task);
}
}
重新测试一下
public static void main(String[] args) {
long thread = ThreadManager.getInstance().getThread("Test");
ThreadManager.getInstance().addBackTask(new TaskModel() {
@Override
public void run() {
System.out.println("addBackTask");
}
});
ThreadManager.getInstance().addTimerTask(new TimerTask(5, 100) {
@Override
public void run() {
System.out.println("TimerTask 5 100");
}
});
ThreadManager.getInstance().addTask(thread, new TaskModel() {
@Override
public void run() {
System.out.println("Thread test");
}
});
}
[04-24 17:40:23:0883:INFO : sz.network.threadpool.BackThread:37 行] -> ---初始化后台线程池--线程数量:10------------
addBackTask
Thread test
[04-24 17:40:23:0888:INFO : sz.network.threadpool.BackThread:89 行] -> 工人<“后台线程-10”> 完成了任务：TaskModel{ID=0, Name=无名, runAttribute={submitTime=1429868423887}} 执行耗时：0 提交耗时：0
[04-24 17:40:23:0888:INFO : sz.network.threadpool.TaskModel:97 行] -> 工人<“Test”> 完成了任务：TaskModel{ID=0, Name=无名, runAttribute={submitTime=1429868423887}} 执行耗时：1 提交耗时：1
TimerTask 5 100
[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
TimerTask 5 100
[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
TimerTask 5 100
[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
TimerTask 5 100
[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
TimerTask 5 100
[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#版本一样。
Java 多线程 自定义线程辅助的更多相关文章
- java多线程与线程间通信
转自(http://blog.csdn.net/jerrying0203/article/details/45563947) 本文学习并总结java多线程与线程间通信的原理和方法,内容涉及java线程 ...
- Java多线程与线程池技术
一.序言 Java多线程编程线程池被广泛使用,甚至成为了标配. 线程池本质是池化技术的应用,和连接池类似,创建连接与关闭连接属于耗时操作,创建线程与销毁线程也属于重操作,为了提高效率,先提前创建好一批 ...
- Java 多线程：线程池
Java 多线程:线程池 作者:Grey 原文地址: 博客园:Java 多线程:线程池 CSDN:Java 多线程:线程池 工作原理 线程池内部是通过队列结合线程实现的,当我们利用线程池执行任务时: ...
- Java多线程之线程其他类
Java多线程之线程其他类 实际编码中除了前面讲到的常用的类之外,还有几个其他类也有可能用得到,这里来统一整理一下: 1,Callable接口和Future接口 JDK1.5以后提供了上面这2个接口, ...
- Java多线程之线程的通信
Java多线程之线程的通信 在总结多线程通信前先介绍一个概念:锁池.线程因为未拿到锁标记而发生的阻塞不同于前面五个基本状态中的阻塞,称为锁池.每个对象都有自己的锁池的空间,用于放置等待运行的线程.这些 ...
- Java多线程之线程的同步
Java多线程之线程的同步 实际开发中我们也经常提到说线程安全问题,那么什么是线程安全问题呢? 线程不安全就是说在多线程编程中出现了错误情况,由于系统的线程调度具有一定的随机性,当使用多个线程来访问同 ...
- Java多线程之线程的控制
Java多线程之线程的控制 线程中的7 种非常重要的状态: 初始New.可运行Runnable.运行Running.阻塞Blocked.锁池lock_pool.等待队列wait_pool.结束Dea ...
- Java多线程父子线程关系 多线程中篇（六）
有的时候对于Java多线程,我们会听到“父线程.子线程”的概念. 严格的说,Java中不存在实质上的父子关系 没有方法可以获取一个线程的父线程,也没有方法可以获取一个线程所有的子线程 子线程的消亡与父 ...
- 关于Java多线程的线程同步和线程通信的一些小问题（顺便分享几篇高质量的博文）
Java多线程的线程同步和线程通信的一些小问题(顺便分享几篇质量高的博文) 前言:在学习多线程时,遇到了一些问题,这里我将这些问题都分享出来,同时也分享了几篇其他博客主的博客,并且将我个人的理解也分享 ...
随机推荐
- bootstrap基本模板
<!DOCTYPE html><!--html5文档格式--> <html lang="zh-CN"><!--申明语言是中文简体--> ...
- SQL Server2000清除数据库日志
sqlserver2000压缩日志 可以将jb51.ldf文件变得很小,方便备份数据库等,在sqlserver查询分析器中执行即可.复制代码 代码如下: DUMP TRANSACTION [jb51] ...
- Principles of measurement of sound intensity
Introduction In accordance with the definition of instantaneous sound intensity as the product of th ...
- CYQ.Data V5 数据库读写分离功能介绍
前言 好多年没写关于此框架的新功能的介绍了,这些年一直在默默地更新,从Nuget上的记录就可以看出来: 这几天在看Java的一些东西,除了觉的Java和.NET的相似度实在太高之外,就是Java太原始 ...
- 初识Opserver，StackExchange的监控解决方案
Opserver是闻名遐迩的网站Stack Overflow的开源监控解决方案,由Stack Exchange发布.它基于.NET框架构建,这在监控工具领域有些与众不同. 旨在为每个受监控系统的健康状 ...
- 使用JavaScript序列化任意复杂的对象
在phonegap的开发中,有时需要知道对象的所有属性,就简单的写了个序列化的方法. 序列化方法如下: function serialize(obj, name) { var result = &qu ...
- Python黑帽编程2.7 异常处理
Python黑帽编程2.7 异常处理 异常是个很宽泛的概念,如果程序没有按预想的执行,都可以说是异常了.遇到一些特殊情况没处理会引发异常,比如读文件的时候文件不存在,网络连接超时.程序本身的错误也可以 ...
- js动态生成选项之考试系统(一)
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"% ...
- JS实战 · 零碎笔记
onclick:单击时触发事件 onmouseover:鼠标进入时触发事件 onmouseout:鼠标离开时触发事件 事件三要素:最基础的内容 事件源:有监听的HTML 标签,能响应事件的HTML ...
- 在互联网公司参与拍卖是一种怎样的感觉？part 1
拍卖在中国是不太流行的一件事,为什么呢?说不太出.当初在外国火的不得了的ebay在交易时采用的就是拍卖出价的模式,但进入中国后这种方式就是玩不转,不得以后来也变成了跟淘宝一样的一口价方式. 话说现在每 ...