任务列表分派给多个线程的策略及方法(含完整代码和演示)

  1package com.unmi.common;
  2
  3import java.util.ArrayList;
  4import java.util.List;
  5
  6/**
  7 * 指派任务列表给线程的分发器
  8 * @author Unmi
  9 * QQ: 1125535 Email: fantasia@sina.com
 10 * MSN: kypfos@msn.com 2008-03-25
 11 */
 12public class TaskDistributor {
 13
 14    /**
 15     * 测试方法
 16     * @param args
 17     */
 18    public static void main(String[] args) {
 19        //初始化要执行的任务列表
 20        List<Task> taskList = new ArrayList<Task>();
 21        for (int i = 0; i < 108; i++) {
 22            taskList.add(new Task(i));
 23        }
 24
 25        //设定要启动的工作线程数为 5 个
 26        int threadCount = 5;
 27        List<Task>[] taskListPerThread = distributeTasks(taskList, threadCount);
 28        System.out.println("实际要启动的工作线程数："+taskListPerThread.length);
 29        for (int i = 0; i < taskListPerThread.length; i++) {
 30            Thread workThread = new WorkThread(taskListPerThread[i],i);
 31            workThread.start();
 32        }
 33    }
 34
 35    /**
 36     * 把 List 中的任务分配给每个线程，先平均分配，剩于的依次附加给前面的线程
 37     * 返回的数组有多少个元素 (List<Task>) 就表明将启动多少个工作线程
 38     * @param taskList 待分派的任务列表
 39     * @param threadCount   线程数
 40     * @return 列表的数组，每个数组中存有该线程要执行的任务列表
 41     */
 42    public static List<Task>[] distributeTasks(List<Task> taskList, int threadCount) {
 43
 44        // 每个线程至少要执行的任务数,假如不为零则表示每个线程都会分配到任务
 45        int minTaskCount = taskList.size() / threadCount;
 46
 47        // 平均分配后还剩下的任务数，不为零则还有任务依个附加到前面的线程中
 48        int remainTaskCount = taskList.size() % threadCount;
 49
 50        // 实际要启动的线程数,如果工作线程比任务还多
 51        // 自然只需要启动与任务相同个数的工作线程，一对一的执行
 52        // 毕竟不打算实现了线程池，所以用不着预先初始化好休眠的线程
 53        int actualThreadCount = minTaskCount > 0 ? threadCount : remainTaskCount;
 54
 55        // 要启动的线程数组，以及每个线程要执行的任务列表
 56        List<Task>[] taskListPerThread = new List[actualThreadCount];
 57
 58        int taskIndex = 0;
 59
 60        //平均分配后多余任务，每附加给一个线程后的剩余数，重新声明与 remainTaskCount
 61        //相同的变量，不然会在执行中改变 remainTaskCount 原有值，产生麻烦
 62        int remainIndces = remainTaskCount;
 63        for (int i = 0; i < taskListPerThread.length; i++) {
 64            taskListPerThread[i] = new ArrayList<Task>();
 65
 66            // 如果大于零，线程要分配到基本的任务
 67            if (minTaskCount > 0) {
 68                for (int j = taskIndex; j < minTaskCount + taskIndex; j++) {
 69                    taskListPerThread[i].add(taskList.get(j));
 70                }
 71                taskIndex += minTaskCount;
 72            }
 73            // 假如还有剩下的，则补一个到这个线程中
 74            if (remainIndces > 0) {
 75                taskListPerThread[i].add(taskList.get(taskIndex++));
 76                remainIndces--;
 77            }
 78        }
 79
 80        // 打印任务的分配情况
 81        for (int i = 0; i < taskListPerThread.length; i++) {
 82            System.out.println("线程 " + i + " 的任务数：" + taskListPerThread[i].size() + "  区间["
 83                    + taskListPerThread[i].get(0).getTaskId() + ","
 84                    + taskListPerThread[i].get(taskListPerThread[i].size() - 1).getTaskId() + "]");
 85        }
 86
 87        return taskListPerThread;
 88    }
 89}
 90
 91/**
 92 * 要执行的任务，可在执行时改变它的某个状态或调用它的某个操作
 93 * 例如任务有三个状态，就绪，运行，完成，默认为就绪态
 94 * 要进一步完善，可为 Task 加上状态变迁的监听器，因之决定UI的显示
 95 */
 96class Task {
 97    public static final int READY = 0;
 98    public static final int RUNNING = 1;
 99    public static final int FINISHED = 2;
100    private int status;
101
102    //声明一个任务的自有业务含义的变量，用于标识任务
103    private int taskId;
104
105    //任务的初始化方法
106    public Task(int taskId){
107        this.status = READY;
108        this.taskId = taskId;
109    }
110
111    /**
112     * 执行任务
113     */
114    public void execute() {
115        // 设置状态为运行中
116        setStatus(Task.RUNNING);
117        System.out.println("当前线程 ID 是：" + Thread.currentThread().getName()
118                +" | 任务 ID 是："+this.taskId);
119        // 附加一个延时
120        try {
121            Thread.sleep(1000);
122        } catch (InterruptedException e) {
123            e.printStackTrace();
124        }
125        // 执行完成，改状态为完成
126        setStatus(FINISHED);
127    }
128
129    public void setStatus(int status) {
130        this.status = status;
131    }
132
133    public int getTaskId() {
134        return taskId;
135    }
136}
137
138/**
139 * 自定义的工作线程，持有分派给它执行的任务列表
140 */
141class WorkThread extends Thread {
142
143    //本线程待执行的任务列表，你也可以指为任务索引的起始值
144    private List<Task> taskList = null;
145    private int threadId;
146
147    /**
148     * 构造工作线程，为其指派任务列表，及命名线程 ID
149     * @param taskList 欲执行的任务列表
150     * @param threadId 线程 ID
151     */
152    public WorkThread(List<Task> taskList,int threadId) {
153        this.taskList = taskList;
154        this.threadId = threadId;
155    }
156
157    /**
158     * 执行被指派的所有任务
159     */
160    public void run() {
161        for (Task task : taskList) {
162            task.execute();
163        }
164    }
165}