common/util/src/main/java/org/opendaylight/yangtools/util/concurrent/TrackingLinkedBlockingQueue.java

   1 /*
   2  * Copyright (c) 2014 Brocade Communications Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.yangtools.util.concurrent;
  10
  11 import java.util.Collection;
  12 import java.util.concurrent.LinkedBlockingQueue;
  13 import java.util.concurrent.TimeUnit;
  14 import java.util.concurrent.atomic.AtomicLong;
  15 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
  16
  17 /**
  18  * A {@link LinkedBlockingQueue} that tracks the largest queue size for debugging.
  19  *
  20  * @author Thomas Pantelis
  21  *
  22  * @param <E> the element t.ype
  23  */
  24 public class TrackingLinkedBlockingQueue<E> extends LinkedBlockingQueue<E> {
  25
  26     private static final long serialVersionUID = 1L;
  27
  28     /**
  29      * Holds largestQueueSize, this long field should be only accessed
  30      * using {@value #LARGEST_QUEUE_SIZE_UPDATER}
  31      */
  32     private volatile long largestQueueSize = 0;
  33
  34     @SuppressWarnings("rawtypes")
  35     private static AtomicLongFieldUpdater<TrackingLinkedBlockingQueue> LARGEST_QUEUE_SIZE_UPDATER = AtomicLongFieldUpdater.newUpdater(TrackingLinkedBlockingQueue.class, "largestQueueSize");
  36
  37     /**
  38      * @see LinkedBlockingQueue#LinkedBlockingQueue
  39      */
  40     public TrackingLinkedBlockingQueue() {
  41         super();
  42     }
  43
  44     /**
  45      * @see LinkedBlockingQueue#LinkedBlockingQueue(Collection)
  46      */
  47     public TrackingLinkedBlockingQueue( Collection<? extends E> c ) {
  48         super(c);
  49     }
  50
  51     /**
  52      * @see LinkedBlockingQueue#LinkedBlockingQueue(int)
  53      */
  54     public TrackingLinkedBlockingQueue( int capacity ) {
  55         super(capacity);
  56     }
  57
  58     /**
  59      * Returns the largest queue size.
  60      */
  61     public long getLargestQueueSize(){
  62         return largestQueueSize;
  63     }
  64
  65     @Override
  66     public boolean offer( E e, long timeout, TimeUnit unit ) throws InterruptedException {
  67         if( super.offer( e, timeout, unit ) ) {
  68             updateLargestQueueSize();
  69             return true;
  70         }
  71
  72         return false;
  73     }
  74
  75     @Override
  76     public boolean offer( E e ) {
  77         if( super.offer( e ) ) {
  78             updateLargestQueueSize();
  79             return true;
  80         }
  81
  82         return false;
  83     }
  84
  85     @Override
  86     public void put( E e ) throws InterruptedException {
  87         super.put( e );
  88         updateLargestQueueSize();
  89     }
  90
  91     @Override
  92     public boolean add( E e ) {
  93         boolean result = super.add( e );
  94         updateLargestQueueSize();
  95         return result;
  96     }
  97
  98     @Override
  99     public boolean addAll( Collection<? extends E> c ) {
 100         try {
 101             return super.addAll( c );
 102         } finally {
 103             updateLargestQueueSize();
 104         }
 105     }
 106
 107     private void updateLargestQueueSize() {
 108         long size = size();
 109         long largest = largestQueueSize;
 110         if( size > largest ) {
 111             LARGEST_QUEUE_SIZE_UPDATER.compareAndSet(this, largest, size );
 112         }
 113     }
 114 }