Java tutorial
/** * Copyright 2010 The Apache Software Foundation * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.hadoop.hbase.regionserver; import java.util.Collection; import java.util.Date; import java.util.HashMap; import java.util.Iterator; import java.util.concurrent.BlockingQueue; import java.util.concurrent.PriorityBlockingQueue; import java.util.concurrent.TimeUnit; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; /** * This class delegates to the BlockingQueue but wraps all HRegions in * compaction requests that hold the priority and the date requested. * * Implementation Note: With an elevation time of -1 there is the potential for * starvation of the lower priority compaction requests as long as there is a * constant stream of high priority requests. */ public class PriorityCompactionQueue implements BlockingQueue<HRegion> { static final Log LOG = LogFactory.getLog(PriorityCompactionQueue.class); /** * This class represents a compaction request and holds the region, priority, * and time submitted. */ private class CompactionRequest implements Comparable<CompactionRequest> { private final HRegion r; private final int p; private final Date date; public CompactionRequest(HRegion r, int p) { this(r, p, null); } public CompactionRequest(HRegion r, int p, Date d) { if (r == null) { throw new NullPointerException("HRegion cannot be null"); } if (d == null) { d = new Date(); } this.r = r; this.p = p; this.date = d; } /** * This function will define where in the priority queue the request will * end up. Those with the highest priorities will be first. When the * priorities are the same it will It will first compare priority then date * to maintain a FIFO functionality. * * <p>Note: The date is only accurate to the millisecond which means it is * possible that two requests were inserted into the queue within a * millisecond. When that is the case this function will break the tie * arbitrarily. */ @Override public int compareTo(CompactionRequest request) { //NOTE: The head of the priority queue is the least element if (this.equals(request)) { return 0; //they are the same request } int compareVal; compareVal = p - request.p; //compare priority if (compareVal != 0) { return compareVal; } compareVal = date.compareTo(request.date); if (compareVal != 0) { return compareVal; } //break the tie arbitrarily return -1; } /** Gets the HRegion for the request */ HRegion getHRegion() { return r; } /** Gets the priority for the request */ int getPriority() { return p; } public String toString() { return "regionName=" + r.getRegionNameAsString() + ", priority=" + p + ", date=" + date; } } /** The actual blocking queue we delegate to */ protected final BlockingQueue<CompactionRequest> queue = new PriorityBlockingQueue<CompactionRequest>(); /** Hash map of the HRegions contained within the Compaction Queue */ private final HashMap<HRegion, CompactionRequest> regionsInQueue = new HashMap<HRegion, CompactionRequest>(); /** Creates a new PriorityCompactionQueue with no priority elevation time */ public PriorityCompactionQueue() { LOG.debug("Create PriorityCompactionQueue"); } /** If the region is not already in the queue it will add it and return a * new compaction request object. If it is already present in the queue * then it will return null. * @param p If null it will use the default priority * @return returns a compaction request if it isn't already in the queue */ protected CompactionRequest addToRegionsInQueue(HRegion r, int p) { CompactionRequest queuedRequest = null; CompactionRequest newRequest = new CompactionRequest(r, p); synchronized (regionsInQueue) { queuedRequest = regionsInQueue.get(r); if (queuedRequest == null || newRequest.getPriority() < queuedRequest.getPriority()) { LOG.trace("Inserting region in queue. " + newRequest); regionsInQueue.put(r, newRequest); } else { LOG.trace("Region already in queue, skipping. Queued: " + queuedRequest + ", requested: " + newRequest); newRequest = null; // It is already present so don't add it } } if (newRequest != null && queuedRequest != null) { // Remove the lower priority request queue.remove(queuedRequest); } return newRequest; } /** Removes the request from the regions in queue * @param remove */ protected CompactionRequest removeFromRegionsInQueue(CompactionRequest remove) { if (remove == null) return null; synchronized (regionsInQueue) { CompactionRequest cr = null; cr = regionsInQueue.remove(remove.getHRegion()); if (cr != null && !cr.equals(remove)) { //Because we don't synchronize across both this.regionsInQueue and this.queue //a rare race condition exists where a higher priority compaction request replaces //the lower priority request in this.regionsInQueue but the lower priority request //is taken off this.queue before the higher can be added to this.queue. //So if we didn't remove what we were expecting we put it back on. regionsInQueue.put(cr.getHRegion(), cr); } if (cr == null) { LOG.warn("Removed a region it couldn't find in regionsInQueue: " + remove.getHRegion()); } return cr; } } public boolean add(HRegion e, int p) { CompactionRequest request = this.addToRegionsInQueue(e, p); if (request != null) { boolean result = queue.add(request); return result; } else { return false; } } @Override public boolean add(HRegion e) { return add(e, e.getCompactPriority()); } public boolean offer(HRegion e, int p) { CompactionRequest request = this.addToRegionsInQueue(e, p); return (request != null) ? queue.offer(request) : false; } @Override public boolean offer(HRegion e) { return offer(e, e.getCompactPriority()); } public void put(HRegion e, int p) throws InterruptedException { CompactionRequest request = this.addToRegionsInQueue(e, p); if (request != null) { queue.put(request); } } @Override public void put(HRegion e) throws InterruptedException { put(e, e.getCompactPriority()); } public boolean offer(HRegion e, int p, long timeout, TimeUnit unit) throws InterruptedException { CompactionRequest request = this.addToRegionsInQueue(e, p); return (request != null) ? queue.offer(request, timeout, unit) : false; } @Override public boolean offer(HRegion e, long timeout, TimeUnit unit) throws InterruptedException { return offer(e, e.getCompactPriority(), timeout, unit); } @Override public HRegion take() throws InterruptedException { CompactionRequest cr = queue.take(); if (cr != null) { removeFromRegionsInQueue(cr); return cr.getHRegion(); } return null; } @Override public HRegion poll(long timeout, TimeUnit unit) throws InterruptedException { CompactionRequest cr = queue.poll(timeout, unit); if (cr != null) { removeFromRegionsInQueue(cr); return cr.getHRegion(); } return null; } @Override public boolean remove(Object r) { if (r instanceof CompactionRequest) { CompactionRequest cr = removeFromRegionsInQueue((CompactionRequest) r); if (cr != null) { return queue.remove(cr); } } return false; } @Override public HRegion remove() { CompactionRequest cr = queue.remove(); if (cr != null) { removeFromRegionsInQueue(cr); return cr.getHRegion(); } return null; } @Override public HRegion poll() { CompactionRequest cr = queue.poll(); if (cr != null) { removeFromRegionsInQueue(cr); return cr.getHRegion(); } return null; } @Override public int remainingCapacity() { return queue.remainingCapacity(); } @Override public boolean contains(Object r) { if (r instanceof HRegion) { synchronized (regionsInQueue) { return regionsInQueue.containsKey((HRegion) r); } } else if (r instanceof CompactionRequest) { return queue.contains(r); } return false; } @Override public HRegion element() { CompactionRequest cr = queue.element(); return (cr != null) ? cr.getHRegion() : null; } @Override public HRegion peek() { CompactionRequest cr = queue.peek(); return (cr != null) ? cr.getHRegion() : null; } @Override public int size() { return queue.size(); } @Override public boolean isEmpty() { return queue.isEmpty(); } @Override public void clear() { regionsInQueue.clear(); queue.clear(); } // Unimplemented methods, collection methods @Override public Iterator<HRegion> iterator() { throw new UnsupportedOperationException("Not supported."); } @Override public Object[] toArray() { throw new UnsupportedOperationException("Not supported."); } @Override public <T> T[] toArray(T[] a) { throw new UnsupportedOperationException("Not supported."); } @Override public boolean containsAll(Collection<?> c) { throw new UnsupportedOperationException("Not supported."); } @Override public boolean addAll(Collection<? extends HRegion> c) { throw new UnsupportedOperationException("Not supported."); } @Override public boolean removeAll(Collection<?> c) { throw new UnsupportedOperationException("Not supported."); } @Override public boolean retainAll(Collection<?> c) { throw new UnsupportedOperationException("Not supported."); } @Override public int drainTo(Collection<? super HRegion> c) { throw new UnsupportedOperationException("Not supported."); } @Override public int drainTo(Collection<? super HRegion> c, int maxElements) { throw new UnsupportedOperationException("Not supported."); } }