多线程--多任务分发

多线程--多任务分发1、⾸先建⽴⼀个任务Task类
public class Task {
//标识任务状态常量
public static final int READY = 0;
public static final int RUNNING = 1;
public static final int FINISHED = 2;
private int status;// 声明⼀个任务的⾃有业务含义的变量，⽤于标识任务
private int taskId;
/**
* 任务初始化的构造⽅法，传⼊⼀个任务ID
* @param taskId
*/
public Task(int taskId) {
this.status = READY;
this.taskId = taskId;
}
/**
* 任务执⾏的⽅法
*/
public void execute() {
// 设置状态为运⾏中
setStatus(Task.RUNNING);
System.out.println("当前线程 ID 是：" + Thread.currentThread().getName() + " | 任务 ID 是：" + this.taskId);
// 附加⼀个延时
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 执⾏完成，改状态为完成
setStatus(FINISHED);
}
public void setStatus(int status) {
this.status = status;
}
public int getTaskId() {
return taskId;
}
}
2、建⽴⼀个继承Thread的⼯作线程类来实现任务Task，⼀个⼯作线程可以实现多个任务。

import java.util.List;
public class WorkThread extends Thread {
// 本线程待执⾏的任务列表，你也可以指为任务索引的起始值
private List<Task> taskList = null;
private int threadId;
/**
* * 构造⼯作线程，为其指派任务列表，及命名线程 ID
*
* @param taskList
* 欲执⾏的任务列表
* @param threadId
* 线程 ID
*/
public WorkThread(List<Task> taskList, int threadId) {
this.taskList = taskList;
this.threadId = threadId;
}
/** * 执⾏被指派的所有任务 */
public void run() {
for (Task task : taskList) {
//调⽤Task的任务执⾏⽅法
task.execute();
}
}
}
3、接下来就是最重要的任务分发管理类了。

import java.util.ArrayList;
import java.util.List;
/**
* 任务分发器
*
* <a href="/index.php?s=/space/1269642" target="_blank">@author</a> Administrator
*
*/
public class TaskManager {
//设置要启动的最⼤⼯作线程数量
public static int threadCount=5;
public static void main(String [] args){
//初始化要执⾏的任务列表
List<Task> taskList=new ArrayList<Task>();
for(int i=0;i<50;i++){
taskList.add(new Task(i));
}
//设置要启动的⼯作线程数量
//int threadCount = 5;
List[] taskListPerThread = managerTasks(taskList, TaskCount.threadCount);
System.out.println("实际要启动的⼯作线程数："+taskListPerThread.length);
for (int i = 0; i < taskListPerThread.length; i++) {
//实际开发时是否需要传⼊短信发送连接对象
Thread workThread = new WorkThread(taskListPerThread[i],i);
workThread.start();
}
}
/**
* 把 List 中的任务分配给每个线程，先平均分配，剩于的依次附加给前⾯的线程返回的数组有多少个元素 (List) 就表明将启动多少个⼯作线程
*
* @param taskList
* 待分派的任务列表
* @param threadCount
* 线程数
* <a href="/index.php?s=/space/34010" target="_blank">@return</a> 列表的数组，每个元素中存有该线程要执⾏的任务列表
*/
public static List[] managerTasks(List<Task> taskList, int threadCount) {
// 每个线程⾄少要执⾏的任务数,假如不为零则表⽰每个线程都会分配到任务
int minTaskCount = taskList.size() / threadCount;
// 平均分配后还剩下的任务数，不为零则还有任务依个附加到前⾯的线程中
int remainTaskCount = taskList.size() % threadCount;
// 实际要启动的线程数,如果⼯作线程⽐任务还多
// ⾃然只需要启动与任务相同个数的⼯作线程，⼀对⼀的执⾏
// 毕竟不打算实现了线程池，所以⽤不着预先初始化好休眠的线程
int actualThreadCount = minTaskCount > 0 ? threadCount : remainTaskCount;
// 要启动的线程数组，以及每个线程要执⾏的任务列表
List<Task> [] taskListPerThread = new List[actualThreadCount];
int taskIndex = 0;
// 平均分配后多余任务，每附加给⼀个线程后的剩余数，重新声明与 remainTaskCount
// 相同的变量，不然会在执⾏中改变 remainTaskCount 原有值，产⽣⿇烦
int remainIndces = remainTaskCount;
for (int i = 0; i < taskListPerThread.length; i++) {
taskListPerThread[i] = new ArrayList<Task>();
// 如果⼤于零，线程要分配到基本的任务
if (minTaskCount > 0) {
for (int j = taskIndex; j < minTaskCount + taskIndex; j++) {
taskListPerThread[i].add(taskList.get(j));
}
taskIndex += minTaskCount;
}
// 假如还有剩下的，则补⼀个到这个线程中
if (remainIndces > 0) {
taskListPerThread[i].add(taskList.get(taskIndex++));
remainIndces--;
}
}
// 打印任务的分配情况
for (int i = 0; i < taskListPerThread.length; i++) {
System.out.println("线程 " + i + " 的任务数：" + taskListPerThread[i].size() + " 区间[" + taskListPerThread[i].get(0).getTaskId() + "," + taskListPerThread[i].get(taskListPerThread[i].size() - 1).getTaskId() + "]"); }
return taskListPerThread;
}
}
4、接下来就是测试了，我们假定有8个任务，同时可以有5个⼯作线程⼯作，结果如下：
线程 0 的任务数：2 任务ID区间[0,1]
线程 1 的任务数：2 任务ID区间[2,3]
线程 2 的任务数：2 任务ID区间[4,5]
线程 3 的任务数：1 任务ID区间[6,6]
线程 4 的任务数：1 任务ID区间[7,7]
实际要启动的⼯作线程数：5
当前线程 ID 是：Thread-1 | 任务 ID 是：2
当前线程 ID 是：Thread-0 | 任务 ID 是：0
当前线程 ID 是：Thread-2 | 任务 ID 是：4
当前线程 ID 是：Thread-3 | 任务 ID 是：6
当前线程 ID 是：Thread-4 | 任务 ID 是：7
当前线程 ID 是：Thread-0 | 任务 ID 是：1
当前线程 ID 是：Thread-2 | 任务 ID 是：5
当前线程 ID 是：Thread-1 | 任务 ID 是：3。