Java：多线程实现任务分发

使用Java多线程实现这种任务分发的策略是：任务列表连续按线程数分段，先保证每线程平均能分配到的任务数，余下的任务从前至后依次附加到线程中--只是数量上，实际每个线程执行的任务都还是连续的。如果出现那种僧多(线程) 粥(任务) 少的情况，实际启动的线程数就等于任务数

实现及演示代码如下：由三个类实现，写在了一个 Java 文件中：TaskDistributor 为任务分发器，Task 为待执行的任务，WorkThread 为自定的工作线程

/**
 * <b>Function: </b> todo
 *
 * @program: 指派任务列表给线程的分发器
 * @Package: com.kingbal.king.dmp
 * @author: songjianlin
 * @date: 2024/01/22
 * @version: 1.0
 * @Copyright: 2024 www.kingbal.com Inc. All rights reserved.
 */
@Slf4j
public class BaseTest {

	public static void main(String[] args) {
		List taskList = new ArrayList();
		for (int i = 0; i < 108; i++) {
			taskList.add(new Task(i));
		}
		//设定要启动的工作线程数为 5 个
		int threadCount = 5;
		List[] taskListPerThread = distributeTasks(taskList, 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 线程数
	 * @return 列表的数组，每个元素中存有该线程要执行的任务列表
	 */
	public static List<Task>[] distributeTasks(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();
			// 如果大于零，线程要分配到基本的任务
			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;
	}
}

 要执行的任务，可在执行时改变它的某个状态或调用它的某个操作

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;

	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;
	}
}

自定义的工作线程，持有分派给它执行的任务列表

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.execute();
		 }
	 }
 }

执行结果如下，注意观察每个Java多线程分配到的任务数量及区间。直到所有的线程完成了所分配到的任务后程序结束： 

大家可以以作参考，例子只是简单实现，具体根据实际业务进行完善