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 com.google.common.annotations.Beta;
  12
  13 import java.util.Collection;
  14 import java.util.concurrent.LinkedBlockingQueue;
  15 import java.util.concurrent.TimeUnit;
  16 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
  17
  18 /**
  19  * A {@link LinkedBlockingQueue} that tracks the largest queue size for debugging.
  20  *
  21  * @author Thomas Pantelis
  22  *
  23  * @param <E> the element t.ype
  24  */
  25 public class TrackingLinkedBlockingQueue<E> extends LinkedBlockingQueue<E> {
  26     @SuppressWarnings("rawtypes")
  27     private static final AtomicIntegerFieldUpdater<TrackingLinkedBlockingQueue> LARGEST_QUEUE_SIZE_UPDATER = AtomicIntegerFieldUpdater.newUpdater(TrackingLinkedBlockingQueue.class, "largestQueueSize");
  28     private static final long serialVersionUID = 1L;
  29
  30     /**
  31      * Holds largestQueueSize, this long field should be only accessed
  32      * using {@link #LARGEST_QUEUE_SIZE_UPDATER}
  33      */
  34     private volatile int largestQueueSize = 0;
  35
  36     /**
  37      * @see LinkedBlockingQueue#LinkedBlockingQueue
  38      */
  39     public TrackingLinkedBlockingQueue() {
  40         super();
  41     }
  42
  43     /**
  44      * @see LinkedBlockingQueue#LinkedBlockingQueue(Collection)
  45      */
  46     public TrackingLinkedBlockingQueue( final Collection<? extends E> c ) {
  47         super(c);
  48     }
  49
  50     /**
  51      * @see LinkedBlockingQueue#LinkedBlockingQueue(int)
  52      */
  53     public TrackingLinkedBlockingQueue( final int capacity ) {
  54         super(capacity);
  55     }
  56
  57     /**
  58      * Returns the largest queue size.
  59      *
  60      * FIXME: the this return will be changed to int in a future release.
  61      */
  62     @Beta
  63     public long getLargestQueueSize() {
  64         return largestQueueSize;
  65     }
  66
  67     @Override
  68     public boolean offer( final E e, final long timeout, final TimeUnit unit ) throws InterruptedException {
  69         if (super.offer( e, timeout, unit ) ) {
  70             updateLargestQueueSize();
  71             return true;
  72         }
  73
  74         return false;
  75     }
  76
  77     @Override
  78     public boolean offer( final E e ) {
  79         if (super.offer( e ) ) {
  80             updateLargestQueueSize();
  81             return true;
  82         }
  83
  84         return false;
  85     }
  86
  87     @Override
  88     public void put( final E e ) throws InterruptedException {
  89         super.put( e );
  90         updateLargestQueueSize();
  91     }
  92
  93     @Override
  94     public boolean add( final E e ) {
  95         boolean result = super.add( e );
  96         updateLargestQueueSize();
  97         return result;
  98     }
  99
 100     @Override
 101     public boolean addAll( final Collection<? extends E> c ) {
 102         try {
 103             return super.addAll( c );
 104         } finally {
 105             updateLargestQueueSize();
 106         }
 107     }
 108
 109     private void updateLargestQueueSize() {
 110         final int size = size();
 111
 112         int largest;
 113         do {
 114             largest = largestQueueSize;
 115         } while (size > largest && !LARGEST_QUEUE_SIZE_UPDATER.weakCompareAndSet(this, largest, size));
 116     }
 117 }