java创建优先权队列

可以使用Java中的PriorityQueue类来创建优先队列。PriorityQueue是一个基于优先级堆的无界优先队列，它的元素按照自然顺序进行排序或者根据构造函数中提供的Comparator进行排序。以下是一个示例代码：

import java.util.PriorityQueue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        // 创建一个优先队列
        PriorityQueue<Integer> pq = new PriorityQueue<>();

        // 添加元素到队列中
        pq.add(5);
        pq.add(1);
        pq.add(10);
        pq.add(3);

        // 输出队列中的元素
        while (!pq.isEmpty()) {
            System.out.print(pq.poll() + " ");
        }
    }
}

输出结果为：1 3 5 10

相关问题

java简单实现优先权算法和轮转法

1. 优先权算法在Java中的简单实现：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class PrioritySchedulingAlgorithm {
    public static void main(String[] args) {
        List<Process> processes = new ArrayList<>();

        // 创建进程对象，并设置对应的优先级和执行时间
        Process p1 = new Process("P1", 2, 10);
        Process p2 = new Process("P2", 1, 5);
        Process p3 = new Process("P3", 3, 8);

        // 将进程添加到列表中
        processes.add(p1);
        processes.add(p2);
        processes.add(p3);

        // 根据优先级对进程进行排序
        Collections.sort(processes, Comparator.comparingInt(Process::getPriority));

        // 执行进程
        for (Process process : processes) {
            System.out.println("执行进程：" + process.getName());
            for (int i = 0; i < process.getExecutionTime(); i++) {
                System.out.println("执行时间片：" + (i + 1));
            }
            System.out.println("完成进程：" + process.getName());
        }
    }

    static class Process {
        private String name;
        private int priority;
        private int executionTime;

        public Process(String name, int priority, int executionTime) {
            this.name = name;
            this.priority = priority;
            this.executionTime = executionTime;
        }

        public String getName() {
            return name;
        }

        public int getPriority() {
            return priority;
        }

        public int getExecutionTime() {
            return executionTime;
        }
    }
}

2. 轮转法在Java中的简单实现：

import java.util.LinkedList;
import java.util.Queue;

public class RoundRobinSchedulingAlgorithm {
    public static void main(String[] args) {
        Queue<Process> processes = new LinkedList<>();

        // 创建进程对象，并设置对应的执行时间
        Process p1 = new Process("P1", 10);
        Process p2 = new Process("P2", 5);
        Process p3 = new Process("P3", 8);

        // 将进程添加到队列中
        processes.add(p1);
        processes.add(p2);
        processes.add(p3);

        // 设置时间片长度
        int timeSlice = 2;

        // 执行进程
        while (!processes.isEmpty()) {
            Process currentProcess = processes.poll();
            System.out.println("执行进程：" + currentProcess.getName());

            // 执行时间片
            for (int i = 0; i < timeSlice && currentProcess.getExecutionTime() > 0; i++) {
                System.out.println("执行时间片：" + (i + 1));
                currentProcess.reduceExecutionTime();
            }

            if (currentProcess.getExecutionTime() > 0) {
                // 将未执行完的进程重新添加到队列中
                processes.add(currentProcess);
            } else {
                System.out.println("完成进程：" + currentProcess.getName());
            }
        }
    }

    static class Process {
        private String name;
        private int executionTime;

        public Process(String name, int executionTime) {
            this.name = name;
            this.executionTime = executionTime;
        }

        public String getName() {
            return name;
        }

        public int getExecutionTime() {
            return executionTime;
        }

        public void reduceExecutionTime() {
            this.executionTime--;
        }
    }
}

以上就是在Java中简单实现优先权算法和轮转法的示例代码。这两种调度算法是常用的进程调度算法，可以根据不同的场景进行选择和使用。

使用Java生成一个抢占式优先权调度算法：只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

在Java中实现抢占式优先级调度算法，你可以利用`PriorityBlockingQueue`结合多线程来完成。这是一种基于阻塞队列的数据结构，它内部使用了优先级堆数据结构，可以自动根据元素的优先级进行排序。

下面是一个简单的示例：

import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

// 定义一个任务类，包含优先级信息
class PriorityTask implements Comparable<PriorityTask> {
    private int priority;
    // 其他任务属性...

    public PriorityTask(int priority) {
        this.priority = priority;
    }

    @Override
    public int compareTo(PriorityTask other) {
        return Integer.compare(this.priority, other.priority);
    }
}

// 创建一个线程池，其中的调度策略是使用优先级队列
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    0, // 核心线程数
    Integer.MAX_VALUE, // 最大线程数
    60L, // 线程空闲时间
    TimeUnit.SECONDS, // 时间单位
    new PriorityBlockingQueue<>()
);

// 当有新的任务到来时，添加并调整优先级
public void submitTask(int priority) {
    PriorityTask task = new PriorityTask(priority);
    executor.execute(task);
}

// 当前线程需要释放CPU时，查看优先级队列并选择最高优先级的任务执行
public Runnable getNextTaskToExecute() {
    if (!executor.isTerminated()) {
        return executor.getQueue().peek(); // 返回队首的任务（即优先级最高的）
    } else {
        return null; // 如果线程池已关闭，返回null
    }
}

在这个例子中，当新的优先级任务提交时，`submitTask`方法会直接放入`PriorityBlockingQueue`，然后`getNextTaskToExecute`会根据队列中的优先级选择下一个执行的任务。这种机制保证了任何时候都是优先级最高的任务得到处理。