stringinterner.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   StringInterner.java

package org.gudy.azureus2.core3.util;

import com.aelitis.azureus.core.util.HashCodeUtils;
import java.io.File;
import java.io.PrintStream;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.net.URL;
import java.util.*;

// Referenced classes of package org.gudy.azureus2.core3.util:
//			ByteArrayHashMap, LightHashSet, AEThread2, SimpleTimer, 
//			TimerEventPerformer, TimerEvent

public class StringInterner
{
	private static class WeakByteArrayEntry extends WeakWeightedEntry
	{

		public boolean equals(Object obj)
		{
			if (this == obj)
				return true;
			if (obj instanceof WeakByteArrayEntry)
			{
				byte myArray[] = getArray();
				byte otherArray[] = ((WeakByteArrayEntry)obj).getArray();
				return myArray != null ? Arrays.equals(myArray, otherArray) : false;
			} else
			{
				return false;
			}
		}

		public byte[] getArray()
		{
			return (byte[])(byte[])get();
		}

		public String toString()
		{
			return (new StringBuilder()).append(super.toString()).append(" ").append(getArray() != null ? new String(getArray()) : "null").toString();
		}

		public WeakByteArrayEntry(byte array[])
		{
			super(array, HashCodeUtils.hashCode(array), array.length + 8);
		}
	}

	private static class WeakEntry extends WeakReference
	{

		private final int hash;

		public boolean equals(Object obj)
		{
			if (this == obj)
				return true;
			if (obj instanceof WeakEntry)
			{
				Object myObj = get();
				Object otherObj = ((WeakEntry)obj).get();
				return myObj != null ? myObj.equals(otherObj) : false;
			} else
			{
				return false;
			}
		}

		public final int hashCode()
		{
			return hash;
		}

		protected WeakEntry(Object o, ReferenceQueue q, int hash)
		{
			super(o, q);
			this.hash = hash;
		}

		public WeakEntry(Object o, ReferenceQueue q)
		{
			super(o, q);
			hash = o.hashCode();
		}
	}

	private static class WeakFileEntry extends WeakWeightedEntry
	{

		public File getFile()
		{
			return (File)get();
		}

		public String toString()
		{
			return (new StringBuilder()).append(super.toString()).append(" ").append(getFile()).toString();
		}

		public WeakFileEntry(File entry)
		{
			super(entry, entry.hashCode(), 40 + entry.getPath().length() * 2);
		}
	}

	private static class WeakStringEntry extends WeakWeightedEntry
	{

		public String getString()
		{
			return (String)get();
		}

		public String toString()
		{
			return (new StringBuilder()).append(super.toString()).append(" ").append(getString()).toString();
		}

		public WeakStringEntry(String entry)
		{
			super(entry, entry.hashCode(), 24 + entry.length() * 2);
		}
	}

	private static class WeakURLEntry extends WeakWeightedEntry
	{

		public URL getURL()
		{
			return (URL)get();
		}

		public boolean equals(Object obj)
		{
			if (this == obj)
				return true;
			if (obj instanceof WeakURLEntry)
			{
				URL my = getURL();
				URL other = ((WeakURLEntry)obj).getURL();
				return my != null ? my.toExternalForm().equals(other.toExternalForm()) : false;
			} else
			{
				return false;
			}
		}

		public String toString()
		{
			return (new StringBuilder()).append(super.toString()).append(" ").append(getURL()).toString();
		}

		public WeakURLEntry(URL entry)
		{
			super(entry, entry.toExternalForm().hashCode(), 176 + entry.toString().length() * 2);
		}
	}

	private static abstract class WeakWeightedEntry extends WeakEntry
	{

		final short size;
		short hits;

		public void incHits()
		{
			if (hits < 32767)
				hits++;
		}

		public void decHits()
		{
			if (hits > 0)
				hits--;
		}

		public String toString()
		{
			return (new StringBuilder()).append(getClass().getName().replaceAll("^.*\\..\\w+$", "")).append(" h=").append(hits).append(";s=").append(size).toString();
		}

		public void destroy()
		{
			hits = -1;
		}

		public boolean isDestroyed()
		{
			return hits == -1;
		}

		public WeakWeightedEntry(Object o, int hash, int size)
		{
			super(o, StringInterner.managedRefQueue, hash);
			this.size = (short)(size & 0x7fff);
		}
	}


	private static final int SCHEDULED_CLEANUP_INTERVAL = 60000;
	private static final boolean TRACE_CLEANUP = false;
	private static final boolean TRACE_MULTIHITS = false;
	private static final int IMMEDIATE_CLEANUP_TRIGGER = 2000;
	private static final int IMMEDIATE_CLEANUP_GOAL = 1500;
	private static final int SCHEDULED_CLEANUP_TRIGGER = 1500;
	private static final int SCHEDULED_CLEANUP_GOAL = 1000;
	private static final int SCHEDULED_AGING_THRESHOLD = 750;
	private static LightHashSet managedInterningSet;
	private static LightHashSet unmanagedInterningSet = new LightHashSet();
	private static final ReferenceQueue managedRefQueue = new ReferenceQueue();
	private static final ReferenceQueue unmanagedRefQueue = new ReferenceQueue();
	private static final String COMMON_KEYS[] = {
		"src", "port", "prot", "ip", "udpport", "azver", "httpport", "downloaded", "Content", "Refresh On", 
		"path.utf-8", "uploaded", "completed", "persistent", "attributes", "encoding", "azureus_properties", "stats.download.added.time", "networks", "p1", 
		"resume data", "dndflags", "blocks", "resume", "primaryfile", "resumecomplete", "data", "peersources", "name.utf-8", "valid", 
		"torrent filename", "parameters", "secrets", "timesincedl", "tracker_cache", "filedownloaded", "timesinceul", "tracker_peers", "trackerclientextensions", "GlobalRating", 
		"comment.utf-8", "Count", "String", "stats.counted", "Thumbnail", "Plugin.<internal>.DDBaseTTTorrent::sha1", "type", "Title", "displayname", "Publisher", 
		"Creation Date", "Revision Date", "Content Hash", "flags", "stats.download.completed.time", "Description", "Progressive", "Content Type", "QOS Class", "DRM", 
		"hash", "ver", "id", "body", "seed", "eip", "rid", "iip", "dp2", "tp", 
		"orig", "dp", "Quality", "private", "dht_backup_enable", "max.uploads", "filelinks", "Speed Bps", "cdn_properties", "sha1", 
		"ed2k", "DRM Key", "Plugin.aeseedingengine.attributes", "initial_seed", "dht_backup_requested", "ta", "size", "DIRECTOR PUBLISH", "Plugin.azdirector.ContentMap", "dateadded", 
		"bytesin", "announces", "status", "bytesout", "scrapes", "passive"
	};
	private static final ByteArrayHashMap byte_map;
	private static final Comparator savingsComp = new Comparator() {

		public int compare(Object o1, Object o2)
		{
			WeakWeightedEntry w1 = (WeakWeightedEntry)o1;
			WeakWeightedEntry w2 = (WeakWeightedEntry)o2;
			return w1.hits * w1.size - w2.hits * w2.size;
		}

	};

	public StringInterner()
	{
	}

	public static String intern(byte bytes[])
	{
		String res = (String)byte_map.get(bytes);
		return res;
	}

	public static String intern(String toIntern)
	{
		if (toIntern == null)
			return null;
		WeakStringEntry checkEntry = new WeakStringEntry(toIntern);
		String internedString;
		synchronized (managedInterningSet)
		{
			sanitize(false);
			WeakStringEntry internedEntry = (WeakStringEntry)managedInterningSet.get(checkEntry);
			if (internedEntry == null || (internedString = internedEntry.getString()) == null)
			{
				internedString = toIntern;
				if (!managedInterningSet.add(checkEntry))
					System.out.println("unexpected modification");
			} else
			{
				internedEntry.incHits();
				checkEntry.destroy();
			}
		}
		if (!toIntern.equals(internedString))
			System.err.println("mismatch");
		return internedString;
	}

	public static byte[] internBytes(byte toIntern[])
	{
		if (toIntern == null)
			return null;
		WeakByteArrayEntry checkEntry = new WeakByteArrayEntry(toIntern);
		byte internedArray[];
		synchronized (managedInterningSet)
		{
			sanitize(false);
			WeakByteArrayEntry internedEntry = (WeakByteArrayEntry)managedInterningSet.get(checkEntry);
			if (internedEntry == null || (internedArray = internedEntry.getArray()) == null)
			{
				internedArray = toIntern;
				if (!managedInterningSet.add(checkEntry))
					System.out.println("unexpected modification");
			} else
			{
				internedEntry.incHits();
				checkEntry.destroy();
			}
		}
		if (!Arrays.equals(toIntern, internedArray))
			System.err.println("mismatch");
		return internedArray;
	}

	public static Object internObject(Object toIntern)
	{
		if (toIntern == null)
			return null;
		WeakEntry checkEntry = new WeakEntry(toIntern, unmanagedRefQueue);
		Object internedItem;
		synchronized (unmanagedInterningSet)
		{
			WeakEntry internedEntry = (WeakEntry)unmanagedInterningSet.get(checkEntry);
			if (internedEntry == null || (internedItem = internedEntry.get()) == null)
			{
				internedItem = toIntern;
				if (!unmanagedInterningSet.add(checkEntry))
					System.out.println("unexpected modification");
			}
			sanitizeLight();
		}
		if (!toIntern.equals(internedItem))
			System.err.println("mismatch");
		return internedItem;
	}

	public static File internFile(File toIntern)
	{
		if (toIntern == null)
			return null;
		WeakFileEntry checkEntry = new WeakFileEntry(toIntern);
		File internedFile;
		synchronized (managedInterningSet)
		{
			sanitize(false);
			WeakFileEntry internedEntry = (WeakFileEntry)managedInterningSet.get(checkEntry);
			if (internedEntry == null || (internedFile = internedEntry.getFile()) == null)
			{
				internedFile = toIntern;
				if (!managedInterningSet.add(checkEntry))
					System.out.println("unexpected modification");
			} else
			{
				internedEntry.incHits();
				checkEntry.destroy();
			}
		}
		if (!toIntern.equals(internedFile))
			System.err.println("mismatch");
		return internedFile;
	}

	public static URL internURL(URL toIntern)
	{
		if (toIntern == null)
			return null;
		WeakURLEntry checkEntry = new WeakURLEntry(toIntern);
		URL internedURL;
		synchronized (managedInterningSet)
		{
			sanitize(false);
			WeakURLEntry internedEntry = (WeakURLEntry)managedInterningSet.get(checkEntry);
			if (internedEntry == null || (internedURL = internedEntry.getURL()) == null)
			{
				internedURL = toIntern;
				if (!managedInterningSet.add(checkEntry))
					System.out.println("unexpected modification");
			} else
			{
				internedEntry.incHits();
				checkEntry.destroy();
			}
		}
		if (!toIntern.toExternalForm().equals(internedURL.toExternalForm()))
			System.err.println("mismatch");
		return internedURL;
	}

	private static void sanitizeLight()
	{
		synchronized (unmanagedInterningSet)
		{
			WeakEntry ref;
			while ((ref = (WeakEntry)(WeakEntry)unmanagedRefQueue.poll()) != null) 
				unmanagedInterningSet.remove(ref);
			unmanagedInterningSet.compactify(-1F);
		}
	}

	private static void sanitize(boolean scheduled)
	{
		synchronized (managedInterningSet)
		{
label0:
			{
				WeakWeightedEntry ref;
				while ((ref = (WeakWeightedEntry)(WeakWeightedEntry)managedRefQueue.poll()) != null) 
					if (!ref.isDestroyed())
						managedInterningSet.remove(ref);
					else
						System.err.println((new StringBuilder()).append("double removal ").append(ref).toString());
				int currentSetSize = managedInterningSet.size();
				if (currentSetSize < 2000 && !scheduled)
					break label0;
				ArrayList remaining = new ArrayList();
				for (Iterator it = managedInterningSet.iterator(); it.hasNext();)
				{
					if (managedInterningSet.size() < 1500 && !scheduled)
						break label0;
					WeakWeightedEntry entry = (WeakWeightedEntry)it.next();
					if (entry.hits == 0)
						it.remove();
					else
						remaining.add(entry);
				}

				currentSetSize = managedInterningSet.size();
				if (currentSetSize >= 1500 || !scheduled)
				{
					if (currentSetSize < 1500 && !scheduled)
						break label0;
					Collections.sort(remaining, savingsComp);
					int i = 0;
					do
					{
						if (i >= remaining.size())
							break;
						currentSetSize = managedInterningSet.size();
						if (currentSetSize < 1000 && scheduled)
							break;
						if (currentSetSize < 1500 && !scheduled)
							break label0;
						WeakWeightedEntry entry = (WeakWeightedEntry)remaining.get(i);
						managedInterningSet.remove(entry);
						i++;
					} while (true);
				}
				currentSetSize = managedInterningSet.size();
				if ((currentSetSize >= 750 || !scheduled) && (currentSetSize >= 1500 || scheduled))
				{
					for (Iterator it = managedInterningSet.iterator(); it.hasNext(); ((WeakWeightedEntry)it.next()).decHits());
				}
			}
			if (scheduled)
				managedInterningSet.compactify(-1F);
		}
		break MISSING_BLOCK_LABEL_388;
		exception;
		throw exception;
	}

	static 
	{
		managedInterningSet = new LightHashSet(800);
		byte_map = new ByteArrayHashMap(COMMON_KEYS.length);
		try
		{
			for (int i = 0; i < COMMON_KEYS.length; i++)
			{
				byte_map.put(COMMON_KEYS[i].getBytes("ISO-8859-1"), COMMON_KEYS[i]);
				managedInterningSet.add(new WeakStringEntry(COMMON_KEYS[i]));
			}

		}
		catch (Throwable e)
		{
			e.printStackTrace();
		}
		(new AEThread2("asyncify", true) {

			public void run()
			{
				SimpleTimer.addPeriodicEvent("StringInterner:cleaner", 60000L, new TimerEventPerformer() {

					final 1 this$0;

					public void perform(TimerEvent event)
					{
						StringInterner.sanitize(true);
						StringInterner.sanitizeLight();
					}

					
					{
						this$0 = 1.this;
						super();
					}
				});
			}

		}).start();
	}



}