/**
* Alipay.com Inc.
* Copyright (c) 2004-2012 All Rights Reserved.
*/
package com.alipay.zdal.common.util;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import org.apache.log4j.Logger;
/**
* �����IJ���HashMap.
* @author ����
* @version $Id: BoundedConcurrentHashMap.java, v 0.1 2014-1-6 ����05:21:39 Exp $
*/
public class BoundedConcurrentHashMap<K, V> extends LinkedHashMap<K, V> {
private static final Logger logger = Logger.getLogger(BoundedConcurrentHashMap.class);
private static final long serialVersionUID = 2615986629983154259L;
private static final int DEFAULT_CAPACITY = 386;
private int capacity;
private final Lock lock = new ReentrantLock();
// private final Lock readLock = lock.readLock();
// private final Lock writeLock = lock.writeLock();
public BoundedConcurrentHashMap(int capacity) {
super(capacity, 0.75f, true);
this.capacity = capacity;
}
public BoundedConcurrentHashMap() {
this(DEFAULT_CAPACITY);
}
@Override
protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
;
boolean ret = size() > capacity;
if (logger.isDebugEnabled()) {
if (ret) {
logger.debug("removeEldestEntry size: " + size() + ", capacity: " + capacity);
}
}
return ret;
}
@Override
public void clear() {
lock.lock();
try {
super.clear();
} finally {
lock.unlock();
}
}
@Override
public Object clone() {
lock.lock();
try {
return super.clone();
} finally {
lock.unlock();
}
}
@Override
public boolean equals(Object o) {
lock.lock();
try {
return super.equals(o);
} finally {
lock.unlock();
}
}
@Override
public int hashCode() {
lock.lock();
try {
return super.hashCode();
} finally {
lock.unlock();
}
}
@Override
public String toString() {
lock.lock();
try {
return super.toString();
} finally {
lock.unlock();
}
}
@Override
public boolean containsValue(Object value) {
lock.lock();
try {
return super.containsValue(value);
} finally {
lock.unlock();
}
}
@Override
public V get(Object key) {
lock.lock();
try {
return super.get(key);
} finally {
lock.unlock();
}
}
@Override
public boolean containsKey(Object key) {
lock.lock();
try {
return super.containsKey(key);
} finally {
lock.unlock();
}
}
@Override
public Set<java.util.Map.Entry<K, V>> entrySet() {
throw new UnsupportedOperationException();
}
@Override
public boolean isEmpty() {
lock.lock();
try {
return super.isEmpty();
} finally {
lock.unlock();
}
}
@Override
public Set<K> keySet() {
throw new UnsupportedOperationException();
}
@Override
public V put(K key, V value) {
lock.lock();
try {
return super.put(key, value);
} finally {
lock.unlock();
}
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
lock.lock();
try {
super.putAll(m);
} finally {
lock.unlock();
}
}
@Override
public V remove(Object key) {
lock.lock();
try {
return super.remove(key);
} finally {
lock.unlock();
}
}
@Override
public int size() {
lock.lock();
try {
return super.size();
} finally {
lock.unlock();
}
}
@Override
public Collection<V> values() {
throw new UnsupportedOperationException();
}
}