Upstream/Paper
1
0
Fork 0
mirror of https://github.com/PaperMC/Paper.git synced 2024-11-28 05:25:42 +01:00
Code Issues Projects Releases Wiki Activity

Removed deprecated ConcurrentSoftMap

Browse Source
This commit is contained in:
Nathan Adams 2011-10-10 22:05:35 +01:00
parent b05d4769d8
commit 1195944c90
3 changed files with 0 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
View File

@ -77,7 +77,6 @@ public class CraftOfflinePlayer implements OfflinePlayer, ConfigurationSerializa
} }
public static OfflinePlayer deserialize(Map<String, Object> args) { public static OfflinePlayer deserialize(Map<String, Object> args) {
System.out.println("Deserializing CraftOfflinePlayer with args " + args);
return Bukkit.getServer().getOfflinePlayer((String)args.get("name")); return Bukkit.getServer().getOfflinePlayer((String)args.get("name"));
} }

271
src/main/java/org/bukkit/craftbukkit/util/ConcurrentSoftMap.java
View File

@ -1,271 +0,0 @@
package org.bukkit.craftbukkit.util;
import com.google.common.collect.MapMaker;
import java.util.Map;
import java.util.LinkedList;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Set;
import java.util.Collection;
import java.util.Iterator;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
/**
* Creates a map that uses soft reference. This indicates to the garbage collector
* that they can be removed if necessary
*
* A minimum number of strong references can be set. These most recent N objects added
* to the map will not be removed by the garbage collector.
*
* Objects will never be removed if they are referenced strongly from somewhere else
* Note: While data corruption won't happen, the garbage collector is potentially async
* This could lead to the return values from containsKey() and similar methods being
* out of date by the time they are used. The class could return null when the object
* is retrieved by a .get() call directly after a .containsKey() call returned true
*
* @deprecated Use {@link MapMaker} to create a concurrent soft-reference map, this class is inefficient and will be removed
* @author raphfrk
*/
@Deprecated
public class ConcurrentSoftMap<K, V> {
private final ConcurrentHashMap<K, SoftMapReference<K, V>> map = new ConcurrentHashMap<K, SoftMapReference<K, V>>();
private final ReferenceQueue<SoftMapReference> queue = new ReferenceQueue<SoftMapReference>();
private final LinkedList<V> strongReferenceQueue = new LinkedList<V>();
private final int strongReferenceSize;
public ConcurrentSoftMap() {
this(20);
}
public ConcurrentSoftMap(int size) {
strongReferenceSize = size;
}
// When a soft reference is deleted by the garbage collector, it is set to reference null
// and added to the queue
//
// However, these null references still exist in the ConcurrentHashMap as keys. This method removes these keys.
//
// It is called whenever there is a method call of the map.
private void emptyQueue() {
SoftMapReference ref;
while ((ref = (SoftMapReference) queue.poll()) != null) {
map.remove(ref.key);
}
}
public void clear() {
synchronized (strongReferenceQueue) {
strongReferenceQueue.clear();
}
map.clear();
emptyQueue();
}
// Shouldn't support this, since the garbage collection is async
public boolean containsKey(K key) {
emptyQueue();
return map.containsKey(key);
}
// Shouldn't support this, since the garbage collection is async
public boolean containsValue(V value) {
emptyQueue();
return map.containsValue(value);
}
// Shouldn't support this since it would create strong references to all the entries
public Set entrySet() {
emptyQueue();
throw new UnsupportedOperationException("SoftMap does not support this operation, since it creates potentially stong references");
}
// Doesn't support these either
public boolean equals(Object o) {
emptyQueue();
throw new UnsupportedOperationException("SoftMap doesn't support equals checks");
}
// This operation returns null if the entry is not in the map
public V get(K key) {
emptyQueue();
return fastGet(key);
}
private V fastGet(K key) {
SoftMapReference<K, V> ref = map.get(key);
if (ref == null) {
return null;
}
V value = ref.get();
if (value != null) {
synchronized (strongReferenceQueue) {
strongReferenceQueue.addFirst(value);
if (strongReferenceQueue.size() > strongReferenceSize) {
strongReferenceQueue.removeLast();
}
}
}
return value;
}
// Doesn't support this either
public int hashCode() {
emptyQueue();
throw new UnsupportedOperationException("SoftMap doesn't support hashCode");
}
// This is another risky method, since again, garbage collection is async
public boolean isEmpty() {
emptyQueue();
return map.isEmpty();
}
// Return all the keys, again could go out of date
public Set keySet() {
emptyQueue();
return map.keySet();
}
// Adds the mapping to the map
public V put(K key, V value) {
emptyQueue();
V old = fastGet(key);
fastPut(key, value);
return old;
}
private void fastPut(K key, V value) {
map.put(key, new SoftMapReference<K, V>(key, value, queue));
synchronized (strongReferenceQueue) {
strongReferenceQueue.addFirst(value);
if (strongReferenceQueue.size() > strongReferenceSize) {
strongReferenceQueue.removeLast();
}
}
}
public V putIfAbsent(K key, V value) {
emptyQueue();
return fastPutIfAbsent(key, value);
}
private V fastPutIfAbsent(K key, V value) {
V ret = null;
if (map.containsKey(key)) {
SoftMapReference<K, V> current = map.get(key);
if (current != null) {
ret = current.get();
}
}
if (ret == null) {
SoftMapReference<K, V> newValue = new SoftMapReference<K, V>(key, value, queue);
boolean success = false;
while (!success) {
SoftMapReference<K, V> oldValue = map.putIfAbsent(key, newValue);
if (oldValue == null) { // put was successful (key didn't exist)
ret = null;
success = true;
} else {
ret = oldValue.get();
if (ret == null) { // key existed, but referenced null
success = map.replace(key, oldValue, newValue); // try to swap old for new
} else { // key existed, and referenced a valid object
success = true;
}
}
}
}
if (ret == null) {
synchronized (strongReferenceQueue) {
strongReferenceQueue.addFirst(value);
if (strongReferenceQueue.size() > strongReferenceSize) {
strongReferenceQueue.removeLast();
}
}
}
return ret;
}
// Adds the mappings to the map
public void putAll(Map other) {
emptyQueue();
Iterator<K> itr = other.keySet().iterator();
while (itr.hasNext()) {
K key = itr.next();
fastPut(key, (V) other.get(key));
}
}
// Remove object
public V remove(K key) {
emptyQueue();
SoftMapReference<K, V> ref = map.remove(key);
if (ref != null) {
return ref.get();
}
return null;
}
// Returns size, could go out of date
public int size() {
emptyQueue();
return map.size();
}
// Shouldn't support this since it would create strong references to all the entries
public Collection values() {
emptyQueue();
throw new UnsupportedOperationException("SoftMap does not support this operation, since it creates potentially stong references");
}
private static class SoftMapReference<K, V> extends SoftReference<V> {
K key;
SoftMapReference(K key, V value, ReferenceQueue queue) {
super(value, queue);
this.key = key;
}
@Override
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (!(o instanceof SoftMapReference)) {
return false;
}
SoftMapReference other = (SoftMapReference) o;
return other.get() == get();
}
}
}

9
src/main/java/org/bukkit/craftbukkit/util/LongHash.java
View File

@ -1,14 +1,5 @@
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package org.bukkit.craftbukkit.util; package org.bukkit.craftbukkit.util;
/**
*
* @author Nathan
*/
public abstract class LongHash { public abstract class LongHash {
static long toLong(int msw, int lsw) { static long toLong(int msw, int lsw) {
return ((long) msw << 32) + lsw - Integer.MIN_VALUE; return ((long) msw << 32) + lsw - Integer.MIN_VALUE;