JAVA每日知识3.25

import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.*;

// 任务类
class Task implements Serializable {
    private final String taskId;
    private final String taskName;
    private final long executionTime;

    public Task(String taskId, String taskName, long executionTime) {
        this.taskId = taskId;
        this.taskName = taskName;
        this.executionTime = executionTime;
    }

    public String getTaskId() {
        return taskId;
    }

    public String getTaskName() {
        return taskName;
    }

    public long getExecutionTime() {
        return executionTime;
    }

    @Override
    public String toString() {
        return "Task{taskId='" + taskId + "', taskName='" + taskName + "', executionTime=" + executionTime + "}";
    }
}

// 任务调度服务器类
class TaskSchedulerServer {
    private static final int PORT = 7070;
    private final ServerSocket serverSocket;
    private final ExecutorService executorService;
    private final PriorityBlockingQueue<Task> taskQueue;
    private final ScheduledExecutorService scheduler;

    public TaskSchedulerServer() throws IOException {
        this.serverSocket = new ServerSocket(PORT);
        this.executorService = Executors.newCachedThreadPool();
        this.taskQueue = new PriorityBlockingQueue<>(10, Comparator.comparingLong(Task::getExecutionTime));
        this.scheduler = Executors.newScheduledThreadPool(1);
        startListening();
        startScheduling();
    }

    private void startListening() {
        executorService.submit(() -> {
            while (true) {
                try {
                    Socket socket = serverSocket.accept();
                    handleClient(socket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    private void handleClient(Socket socket) {
        executorService.submit(() -> {
            try (ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
                 ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream())) {
                String command = (String) in.readObject();
                if ("SUBMIT".equals(command)) {
                    Task task = (Task) in.readObject();
                    taskQueue.add(task);
                    out.writeObject("Task submitted successfully");
                }
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            } finally {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    private void startScheduling() {
        scheduler.scheduleAtFixedRate(() -> {
            long currentTime = System.currentTimeMillis();
            while (!taskQueue.isEmpty() && taskQueue.peek().getExecutionTime() <= currentTime) {
                Task task = taskQueue.poll();
                executorService.submit(() -> {
                    System.out.println("Executing task: " + task);
                    // 模拟任务执行
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }
        }, 0, 1, TimeUnit.SECONDS);
    }

    public void shutdown() {
        try {
            serverSocket.close();
            executorService.shutdown();
            scheduler.shutdown();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 任务调度客户端类
class TaskSchedulerClient {
    private final String serverAddress;
    private final int serverPort;

    public TaskSchedulerClient(String serverAddress, int serverPort) {
        this.serverAddress = serverAddress;
        this.serverPort = serverPort;
    }

    public void submitTask(Task task) {
        try (Socket socket = new Socket(serverAddress, serverPort);
             ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
             ObjectInputStream in = new ObjectInputStream(socket.getInputStream())) {
            out.writeObject("SUBMIT");
            out.writeObject(task);
            String response = (String) in.readObject();
            System.out.println(response);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

// 主类，用于测试分布式任务调度系统
public class DistributedTaskSchedulerTest {
    public static void main(String[] args) throws IOException {
        TaskSchedulerServer server = new TaskSchedulerServer();

        TaskSchedulerClient client = new TaskSchedulerClient("localhost", 7070);
        Task task1 = new Task(UUID.randomUUID().toString(), "Task1", System.currentTimeMillis() + 5000);
        client.submitTask(task1);

        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        server.shutdown();
    }
}

代码说明

Task 类：表示一个任务，包含任务 ID、任务名称和执行时间。
TaskSchedulerServer 类：作为任务调度服务器，监听指定端口，接收客户端提交的任务。使用 PriorityBlockingQueue 存储任务，根据任务的执行时间进行排序。启动一个定时任务，每秒检查一次队列，执行到期的任务。
TaskSchedulerClient 类：作为任务调度客户端，与服务器进行通信，提交任务。
DistributedTaskSchedulerTest 类：包含 main 方法，用于测试分布式任务调度系统的基本功能，包括提交任务和等待任务执行。