एक प्राथमिक संपत्ति के अनुसार प्राथमिकता Queue से तत्व कैसे निकालें?

Question

मैं को अपने PQueue के अंदर सेट करने का प्रयास कर रहा हूं। यह Maximum Waiting TimePQueue स्वचालित रूप से जांच करेगा यदि linksMaximum Waiting Time से अधिक को हटाने के लिए प्रतीक्षा कर रहे हैं। मैंने अपने कोड में यह परिवर्तन किया है यह काम कर रहा है लेकिन यह लिंक हटाने के ठीक बाद रोक रहा है। मैं प्रतीक्षा समय की स्थिति के अनुसार अपने PQueue से सभी तत्वों को हटाना चाहता हूं। क्या आप मुझे बता सकते हैं कि मैं यहां क्या खो रहा हूं?

यह मेरी कक्षा है:

public class MyClass { 

    public static PriorityQueue <LinkNodeLight> PQueue = new PriorityQueue <>(); 


    private static Set<String> DuplicationLinksHub = new LinkedHashSet <>();   

    private static Integer IntraLinkCount = new Integer (0);     
    private static Integer InterLinkCount = new Integer (0);     
    private static Integer DuplicationLinksCount = new Integer (0);  
    private static Integer MaxWaitTime = new Integer (60000); // 1 M= 60000 MS 


    @SuppressWarnings("null") 
    LinkNode deque(){ 

     LinkNode link = null; 
     synchronized (PQueue) { 

      link = (LinkNode) PQueue.poll(); 
      if (link != null) { 
       link.setDequeTime(new DateTime()); 
       if (link.isInterLinks()) 
        synchronized (InterLinkCount) { 
         InterLinkCount--; 
         } 
       else 
        synchronized (IntraLinkCount) { 
         IntraLinkCount--; 
         } 
      } 

      synchronized (PQueue) { 
       if (link.waitingInQueue()>MaxWaitTime) { 

        link = (LinkNode) PQueue.remove(); 
            System.out.println("*********************************"); 
            System.out.println("This Link is Deopped: " + link); 
            System.out.println("%%% MaX Waiting Time:" + (MaxWaitTime/60000)+"Min"); 

            System.out.println("*********************************"); 
        } 
      } 
      return link; 


     } 

Answer 1

आपका प्रश्न थोड़ा अपारदर्शी है, लेकिन अगर मैं इसे सही ढंग से समझते हैं कि आप अपने PriorityQueue जाँच करने के लिए अगर वहाँ आइटम है कि एक विशिष्ट समय से अधिक समय बीत चुके हैं देखना चाहते हैं।

IntraLinkCount और InterLinkCount पर आपका उपयोग पहले से ही उल्लेख किया गया है, जैसा कि पहले से ही उल्लेख किया गया है, थोड़ा अजीब है। एक काफी अज्ञात विकल्प, परमाणु पूर्णांक वर्ग AtomicInteger (पैकेज java.util.concurrent.atomic में नहीं है:।।

private static AtomicInteger IntraLinkCount = Integer.valueOf(0); 

इस के रूप में आप चाहते हैं काम करेंगे

दूसरी समस्या यह है कि आप poll() विधि का उपयोग है यह होगा कतार से शीर्ष आइटम को हटा दें। हो सकता है कि आप के बजाय peek() उपयोग करना चाहते हैं, और उसके बाद ही remove() अगर लौटे लिंक वस्तु को संतुष्ट करता है link.waitingInQueue() > MaxWaitTime?

का उपयोग जिस तरह से, वाई तक हमारी कतार वस्तुओं को उनके "प्राकृतिक क्रम" के अनुसार वापस कर देगी। इसका मतलब है कि compareTo विधि का उपयोग किया जाता है, और "सबसे छोटा" कतार से पहले वापस किया जाएगा। मुझे लगता है कि आप एक कस्टम compareTo लागू करना चाहते हैं जो सबसे लंबे समय तक प्रतीक्षा लिंक को इसके बजाय पहले रखता है?

आप इसके बजाय create your PriorityQueue with a custom Comparator ऑब्जेक्ट भी कर सकते हैं।

कुछ इस तरह:

public class MyClass { 
    public static PriorityQueue<LinkNodeLight> PQueue = new PriorityQueue<>(); 

    private static AtomicInteger IntraLinkCount = new AtomicInteger(0); 
    private static AtomicInteger InterLinkCount = new AtomicInteger(0); 

    private static Integer MaxWaitTime = Integer.valueOf(60_000); // 1 M= 60000 MS 

    LinkNode deque() { 
     LinkNode link = null; 

     synchronized (PQueue) { 
      link = PQueue.peek(); 

      if (link != null) { 
       link.setDequeTime(LocalDateTime.now()); 

       if (link.isInterLinks()) 
        InterLinkCount.decrementAndGet(); 
       else 
        IntraLinkCount.decrementAndGet(); 

       if (link.waitingInQueue() > MaxWaitTime) { 
        link = PQueue.remove(); 

        System.out.println("*********************************"); 
        System.out.println("This Link is Deopped: " + link); 
        System.out.println("%%% MaX Waiting Time:" + MaxWaitTime/60000 + "Min"); 
        System.out.println("*********************************"); 

        return link; 
       } else 
        return null; 
      } 
     } 

     return link; // Not sure what you want to return here 
    } 
} 

आप भाग्यशाली जावा 8 पर हो रहे हैं, तो इस तरह की कुछ जादू बजाय उपयोगी हो सकता है:

synchronized (PQueue) { 
    link = PQueue.stream().filter(node -> node.waitingInQueue() > MaxWaitTime).findFirst().orElse(null); 

    if (link != null) 
     PQueue.remove(link); 
}