Java多线程之任务分发

题引：

老师有3个同类任务，需要5个同学ABCDE分别都要处理完成。老师分配任务的策略是：每个任务都是随机分配下去的，每个同学拿到任务后都要完成这个任务。

像极了做数学题时的套路，这个题目其实就属于Java多线程之任务分发的模式。

在实际工作中，如果我们遇到了“要把多个同类任务分派给Java的多个线程去执行”的场景，需要思考如下的问题：

（1）待执行的任务列表是什么？
（2）需要启动多少Java线程去执行任务？
（3）每个Java线程实际要执行多少任务？（or：任务如何分发给每个Java线程？）

思考之后，我们还需要知道，Java多线程实现这种任务分发的一般策略是什么，为了便于下文叙述方便，我们先约定：

（1）任务数为taskNum
（2）计划启动线程数为planThreadNum
（3）实际启动线程数为realThreadNum

（1）确认实际启动的线程数：

如果taskNum < planThreadNum，则实际启动taskNum个线程，即一个线程执行一个任务；

如果taskNum众多，则实际启动planThreadNum个线程即可。

（2）确定每个线程执行的任务数：

如果taskNum < planThreadNum，每个线程都只执行一个任务；

如果taskNum众多，则先将taskNum按planThreadNum均分，余下的任务从前至后依次附加到线程中即可。

现在，我们既知道了多任务分发该思考哪些问题，也明白了Java多线程处理任务分发的一般策略，该如何解决题引中的问题呢？由题设和上文中的策略可知：

（1）我们需要一个Task类，来定义任务的状态（就绪、执行中、结束）和任务的行为（执行）
（2）我们需要一个Teacher类，来执行任务分配的工作
（3）我们需要一个StudentWorkThread类，来定义学生的工作线程，由该线程来执行任务
（4）我们需要一个DoTeacherWork的测试类，用来测试题引中的场景

（1）Task类：

public class Task {

    private static final int READY = 0;
    private static final int RUNNING = 1;
    private static final int FINISHED = 2;

    // 执行任务的状态
    private int status;
    // 用于标识任务
    private int 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(Task.FINISHED);
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public int getTaskId() {
        return taskId;
    }

}

（2）Teacher类：

public class Teacher {

    public static List[] distributeTasks(List taskList, int threadCount) {
        // 每个线程至少执行的任务数
        int minTaskCount = taskList.size() / threadCount;
        // 平均分配后还剩余的任务数
        int remainTaskCount = taskList.size() % threadCount;
        // 实际启动的线程数，如果实际工作的线程大于工作任务数，则启动任务数个线程即可
        int actualThreadCount = minTaskCount > 0 ? threadCount : remainTaskCount;
        // 要启动的线程数组，以及每个线程要执行的任务列表
        List[] perThreadWorkList = new List[actualThreadCount];
        int taskIndex = 0;
        // 任务剩余数重新声明标志，防止在执行过程中改变剩余线程数remainTaskCount的值
        int remainIndces = remainTaskCount;

        for (int i = 0; i < perThreadWorkList.length; i++) {
            perThreadWorkList[i] = new ArrayList();
            // 如果每个线程至少要执行的任务数>0，线程需要分配到基本任务
            if (minTaskCount > 0) {
                for (int j = taskIndex; j < minTaskCount + taskIndex; j++) {
                    perThreadWorkList[i].add(taskList.get(j));
                }
            }
            taskIndex += minTaskCount;

            // 还有剩余的任务，则补充一个到这个线程中
            if (remainIndces > 0) {
                perThreadWorkList[i].add(taskList.get(taskIndex++));
                remainIndces--;
            }
        }

        // 打印任务的分配情况
        for (int i = 0; i < perThreadWorkList.length; i++) {
            System.out.println("线程" + i + "任务数: " + perThreadWorkList[i].size() +
                    ",区间[" + ((Task) perThreadWorkList[i].get(0)).getTaskId() + "," +
                    ((Task) perThreadWorkList[i].get(perThreadWorkList[i].size() - 1)).getTaskId() + "]");
        }

        return perThreadWorkList;
    }
    
}

（3）StudentWorkThread类：

public class StudentWorkThread extends Thread {

    private List<Task> taskList = null;
    private int threadId;

    public StudentWorkThread(List<Task> taskList, int threadId) {
        this.taskList = taskList;
        this.threadId = threadId;
    }

    // 执行被指派的任务
    public void run() {
        for (Task task : taskList) {
            task.execute();
        }
    }

}

（4）DoTeacherWork类：

public class DoTeacherWork {

    public static void main(String[] args) {
        // 构建老师的任务列表
        List<Task> taskList = new ArrayList<Task>();
        for (int i = 0; i < 3; i++) {
            taskList.add(new Task(i));
        }

        System.out.println("老师的任务列表数：" + taskList.size());

        // 设定学生工作的线程数为5
        int threadNum = 5;

        List[] perThreadWorkList = Teacher.distributeTasks(taskList, threadNum);

        System.out.println("实际要启动的工作线程数：" + perThreadWorkList.length);

        for (int i = 0; i < perThreadWorkList.length; i++) {
            StudentWorkThread studentWorkThread = new StudentWorkThread(perThreadWorkList[i], i);
            studentWorkThread.start();
        }
    }

}

结束语：题引中的任务分发只是一个简单的Java多线程应用场景，在实际工作中，在每一个思考环节的处理上，都可以进行扩展和细化需求。在此就不进行阐述了。