Considerations for using redisson to operate distributed queues

Say first conclusion :
Use Redisson Provided RedissonPriorityQueue when , Compare operations that do not use objects equals, But use compare Compare .

Recently, I did a service for scheduled tasks , Distributed priority queues are required , I chose Redisson library .
Redisson There are many queues , Also inherited java Bag Queue Interface , It looks very convenient .
After modifying the code , I found a very strange problem , After adding an element , It can't be removed , remove Back to false.
Element is a custom class , Rewrote equals and hashcode, So there should be no problem , Use java con The queue in the package is all right .
This is very strange , Redisson Although the interface is implemented , But the expected behavior is wrong , Don't pass equals Function to compare whether the elements are the same ,
Through code analysis RedissonPriorityQueue To find out why ( Show only key code ):

    @Override
    public boolean remove(Object value) {
            BinarySearchResult<V> res = binarySearch((V) value, codec);
            remove((int) res.getIndex());
    }

above remove The function display uses binarySearch Element found , Then delete it

    public BinarySearchResult<V> binarySearch(V value, Codec codec) {
          // Call the comparator 
            int cmp = comparator.compare(value, res);
            if (cmp == 0) {
                //...
            } else if (cmp < 0) {
                // ...
            } else {
                // ...
            }
        }
    }

The above code indicates that the comparator.compare Compare two elements , Returns the position of the element in the queue

  // Comparator code 
   private Comparator<? super V> comparator = NaturalComparator.NATURAL_ORDER;
      private static class NaturalComparator<V> implements Comparator<V>, Serializable {

        private static final long serialVersionUID = 7207038068494060240L;

        static final NaturalComparator NATURAL_ORDER = new NaturalComparator();

        public int compare(V c1, V c2) {
            Comparable<Object> c1co = (Comparable<Object>) c1;
            Comparable<Object> c2co = (Comparable<Object>) c2;
            return c1co.compareTo(c2co);
        }

    }

You can see that the comparator finally calls c1co.compareTo(c2co) To compare two elements .
Generally speaking , compare The function compares the priority of two elements , Instead of comparing whether the contents of two elements are the same , but RedissonPriorityQueue break with convention , Not only use compare To compare priorities , It is also used to compare whether the elements are the same .
So be very careful compare Implementation of function , For example, a task ( The task name uniquely identifies a task , Time as a priority ), It can be written like this :

    @Override
    public int compareTo(TaskNode o) {
        if (getName().equals(o.getName())) {
            // The same name ,  Description is the same task 
            return 0;
        }
        // Compare delay 
        long diffMs = getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS);
        if (diffMs == 0) {
            // Same delay , Comparison name 
            return getName().compareTo(o.getName());
        }
        return diffMs > 0 ? 1 : -1;
    }