JAVA多线程之实现用户任务排队并预估排队时长

问题描述

我们在开发一个应用程序时，可能需要实现任务排队功能，以确保多个用户提交的任务可以依次执行，并预估排队时长，方便用户等待。本文将介绍如何使用Java多线程技术实现用户任务排队并预估排队时长。

方案概述

我们可以使用Java的线程池技术实现任务排队功能。Java线程池是一种机制，它可以维护一组线程，以便在线程可用时将其重用。这可以避免每次都创建新的线程，从而提高程序的性能。

要预估排队时长，我们可以根据当前任务队列中的任务数和处理任务所需时间的平均值计算出预估时间。这种方法可以为用户提供一个大致的等待时间。

方案实现

1.创建任务类

首先，我们需要创建一个描述用户任务的Java类。这个类应该包含用户ID，任务开始时间和任务结束时间等属性。我们可以按照以下方式创建一个简单的任务类：

public class Task {
    private int userId;
    private long startTime;
    private long endTime;

    public Task(int userId, long startTime) {
        this.userId = userId;
        this.startTime = startTime;
    }

    public int getUserId() {
        return userId;
    }

    public long getStartTime() {
        return startTime;
    }

    public long getEndTime() {
        return endTime;
    }

    public void setEndTime(long endTime) {
        this.endTime = endTime;
    }
}

2.创建任务队列类

接下来，我们需要创建一个任务队列类，用于存储用户任务并管理任务的排队。我们可以按照以下方式实现任务队列类：

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TaskQueue {

    private Queue<Task> queue = new LinkedList<>();
    private ExecutorService executor = Executors.newFixedThreadPool(10);
    private int maxAverageTime; // 预估平均时间

    public TaskQueue(int maxAverageTime) {
        this.maxAverageTime = maxAverageTime;
    }

    public void addTask(Task task) {
        queue.offer(task);
    }

    public void start() {
        while (!queue.isEmpty()) {
            if (canExecuteTask()) {
                Task task = queue.poll();
                task.setEndTime(System.currentTimeMillis());
                executor.execute(new TaskProcessor(task, maxAverageTime));
            }
        }
        executor.shutdown();
    }

    private boolean canExecuteTask() {
        return queue.size() > 0;
    }

}

这里的TaskQueue类包含一个任务队列和一个线程池，我们可以使用addTask()方法将任务添加到队列中，使用start()方法启动任务处理程序。

3.创建任务处理程序类

接下来，我们需要创建任务处理程序类，用于从任务队列中获取任务并执行任务。在处理任务时，我们可以根据预估时间计算出任务处理时间并将任务结束时间设置为开始时间加上任务处理时间。

public class TaskProcessor implements Runnable {
    private Task task;
    private int maxAverageTime;

    public TaskProcessor(Task task, int maxAverageTime) {
        this.task = task;
        this.maxAverageTime = maxAverageTime;
    }

    @Override
    public void run() {
        long processingTime = (long) (Math.random() * maxAverageTime * 2);
        try {
            Thread.sleep(processingTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        task.setEndTime(task.getStartTime() + processingTime);
        System.out.println("User " + task.getUserId() + " has been processed. End time: " + task.getEndTime());
    }
}

这里的TaskProcessor类实现了Runnable接口，用于执行任务。在处理任务时，我们使用Thread.sleep()方法模拟任务处理时间，然后将任务结束时间设置为开始时间加上任务处理时间。

4.使用示例1

现在，我们将编写一个简单的示例程序来演示如何使用TaskQueue类和TaskProcessor类来实现任务排队功能。以下是示例程序的实现：

public class Demo1 {
    public static void main(String[] args) {
        TaskQueue taskQueue = new TaskQueue(5000);
        taskQueue.addTask(new Task(1, System.currentTimeMillis()));
        taskQueue.addTask(new Task(2, System.currentTimeMillis()));
        taskQueue.addTask(new Task(3, System.currentTimeMillis()));
        taskQueue.start();
    }
}

在这个示例程序中，我们将创建一个TaskQueue实例并添加三个不同的用户任务。我们使用start()方法启动任务队列，任务将被依次执行，并输出每个任务的结束时间。

5.使用示例2

我们还可以编写另一个示例程序来演示如何预估排队时间。以下是示例程序的实现：

public class Demo2 {
    public static void main(String[] args) throws InterruptedException {
        TaskQueue taskQueue = new TaskQueue(500);
        taskQueue.addTask(new Task(1, System.currentTimeMillis()));
        taskQueue.addTask(new Task(2, System.currentTimeMillis()));
        taskQueue.addTask(new Task(3, System.currentTimeMillis()));
        taskQueue.addTask(new Task(4, System.currentTimeMillis()));

        taskQueue.start();

        long endTime = System.currentTimeMillis();
        long startTime = endTime - taskQueue.maxAverageTime * taskQueue.queue.size();
        System.out.println("Estimated waiting time: " + (endTime - startTime));
    }
}

在这个示例程序中，我们将创建一个TaskQueue实例并添加四个任务。我们使用start()方法启动任务队列，并使用taskQueue.queue.size()和taskQueue.maxAverageTime计算预估时间。