用循环链表实现一个优先级消息队列

如图，E类相当于一个节点，next指向下一个节点，第一个节点需要特殊处理，读写的时候需要加一把锁。ok

public class CPriorityMsgQueue {
    static E e = new E();
    static final Object lock = new Object();

    public static void main(String[] args) {
        //起一个线程模拟出队列
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    Integer out = deQueue();
                    if (!Objects.isNull(out)){
                        System.out.println("出队列->>：" + out);
                    }
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t.start();
        while (true) {
            Scanner scan = new Scanner(System.in);
            int inputVal = scan.nextInt();
            enQueue(new E(inputVal, e));
        }
    }

    /**
     * 入队列
     *
     * @param msg
     */
    static void enQueue(E msg) {
        synchronized (lock) {
            if (Objects.isNull(e.val)) {
                e = msg;
                e.next = e;
            } else {
                E oldE = e;
                E newE = e;
                while (newE.next != oldE) {
                    newE = newE.next;
                }
                newE.next = msg;
            }
        }
        System.out.println("入队列<<-：" + msg.val);
    }

    /**
     * 出队列
     *
     * @return
     */
    static Integer deQueue() {
        /**
         * 队列为空，返回null
         */
        if (Objects.isNull(e.val)) {
            return null;
        }
        E oldE = e;
        E newE = e;
        synchronized (lock) {
            /**
             * 如果一个节点，直接返回
             */
            if (oldE == newE.next) {
                Integer m = oldE.val;
                e = new E();
                return m;
            }
        }

        Integer min = e.val;
        do {
            if (newE.next.val < min) {
                min = newE.next.val;
            } else {
                newE = newE.next;
            }
        } while (oldE != newE.next);

        while (!e.next.val.equals(min)) {
            e = e.next;
        }
        //多个节点取的时候，应该要加锁
        synchronized (lock) {
            e.next = e.next.next;
        }
        return min;
    }
}

/**
 * 循环列表节点
 */
class E {
    /**
     * 对应的值
     */
    Integer val;
    /**
     * 对应的指针
     */
    E next;

    public E() {
    }

    public E(Integer val, E next) {
        this.val = val;
        this.next = next;
    }
}