All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.zving.preloader.ReferenceCleaner Maven / Gradle / Ivy
package com.zving.preloader;
import java.beans.Introspector;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.concurrent.ThreadPoolExecutor;
public class ReferenceCleaner
{
private static final List JVM_THREAD_GROUP_NAMES = new ArrayList();
private static final String JVN_THREAD_GROUP_SYSTEM = "system";
private PreClassLoader loader;
static
{
JVM_THREAD_GROUP_NAMES.add("system");
JVM_THREAD_GROUP_NAMES.add("RMI Runtime");
}
public ReferenceCleaner(PreClassLoader loader)
{
this.loader = loader;
}
protected void clearReferences()
{
clearReferencesJdbc();
clearReferencesThreads();
clearReferencesThreadLocals();
clearReferencesRmiTargets();
clearReferencesStaticFinal();
try
{
Class clazz = Class.forName("org.apache.commons.logging.LogFactory");
if (clazz != null)
{
Method m = clazz.getMethod("release", new Class[] { ClassLoader.class });
m.invoke(null, new Object[] { this.loader });
}
}
catch (Exception localException) {}
clearReferencesResourceBundles();
Introspector.flushCaches();
this.loader = null;
}
private final void clearReferencesJdbc()
{
InputStream is;
byte classBytes[];
int offset;
is = loader.getResourceAsStream("com/zving/preloader/JdbcLeakPrevention.class");
classBytes = new byte[2048];
offset = 0;
try
{
for(int read = is.read(classBytes, offset, classBytes.length - offset); read > -1; read = is.read(classBytes, offset, classBytes.length - offset))
{
offset += read;
if(offset == classBytes.length)
{
byte tmp[] = new byte[classBytes.length * 2];
System.arraycopy(classBytes, 0, tmp, 0, classBytes.length);
classBytes = tmp;
}
}
Class lpClass = loader.defineClassEx("com.zving.preloader.JdbcLeakPrevention", classBytes, 0, offset, getClass().getProtectionDomain());
Object obj = lpClass.newInstance();
List driverNames = (List)obj.getClass().getMethod("clearJdbcDriverRegistrations", new Class[0]).invoke(obj, new Object[0]);
String name;
for(Iterator iterator = driverNames.iterator(); iterator.hasNext(); System.out.println((new StringBuilder("Clear JDBC reference success:")).append(name).toString()))
name = (String)iterator.next();
}
catch(Exception e)
{
System.out.println((new StringBuilder("Clear JDBC reference failed:")).append(e.getMessage()).toString());
}
if(is != null)
try
{
is.close();
}
catch(IOException ioexception) { }
}
private final void clearReferencesStaticFinal()
{
Class[] arr = new Class[this.loader.getLoadedClasses().size()];
arr = (Class[])this.loader.getLoadedClasses().toArray(arr);
Class[] arrayOfClass1;
int j = (arrayOfClass1 = arr).length;
for (int k = 0; k < j; k++)
{
Class clazz = arrayOfClass1[k];
try
{
Field[] fields = clazz.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
if (Modifier.isStatic(fields[i].getModifiers()))
{
fields[i].get(null);
break;
}
}
}
catch (Throwable localThrowable1) {}
}
j = (arrayOfClass1 = arr).length;
for (Class clazz: arrayOfClass1)
{
// Class clazz = arrayOfClass1[i];
try
{
Field[] fields = clazz.getDeclaredFields();
for (int i = 0; i < fields.length; i++)
{
Field field = fields[i];
int mods = field.getModifiers();
if ((!field.getType().isPrimitive()) && (field.getName().indexOf("$") == -1)) {
if (Modifier.isStatic(mods)) {
try
{
field.setAccessible(true);
if (Modifier.isFinal(mods))
{
if ((!field.getType().getName().startsWith("java.")) && (!field.getType().getName().startsWith("javax."))) {
nullInstance(field.get(null));
}
}
else {
field.set(null, null);
}
}
catch (Throwable localThrowable2) {}
}
}
}
}
catch (Throwable t)
{
t.printStackTrace();
}
}
}
private void nullInstance(Object instance)
{
if (instance == null) {
return;
}
Field[] fields = instance.getClass().getDeclaredFields();
for (int i = 0; i < fields.length; i++)
{
Field field = fields[i];
int mods = field.getModifiers();
if ((!field.getType().isPrimitive()) && (field.getName().indexOf("$") == -1)) {
try
{
field.setAccessible(true);
if ((!Modifier.isStatic(mods)) || (!Modifier.isFinal(mods)))
{
Object value = field.get(instance);
if (value != null)
{
Class valueClass = value.getClass();
if (loadedByThisOrChild(valueClass)) {
field.set(instance, null);
}
}
}
}
catch (Throwable t)
{
t.printStackTrace();
}
}
}
}
protected boolean loadedByThisOrChild(Class clazz)
{
boolean result = false;
for (ClassLoader classLoader = clazz.getClassLoader(); classLoader != null; classLoader = classLoader.getParent()) {
if (classLoader.equals(this))
{
result = true;
break;
}
}
return result;
}
private boolean threadNeedClear(Thread thread)
{
if (thread == Thread.currentThread()) {
return false;
}
ThreadGroup tg = thread.getThreadGroup();
if ((tg != null) && (JVM_THREAD_GROUP_NAMES.contains(tg.getName())))
{
if (thread.getName().equals("Keep-Alive-Timer")) {
thread.setContextClassLoader(this.loader.getParent());
}
return false;
}
if (!thread.isAlive()) {
return false;
}
if (thread.getContextClassLoader() == this.loader) {
return true;
}
if (thread.getClass().getClassLoader() == this.loader) {
return true;
}
Object target = null;
String[] arrayOfString;
int j = (arrayOfString = new String[] { "target", "runnable", "action" }).length;
for (int i = 0; i < j; i++)
{
String fieldName = arrayOfString[i];
try
{
Field targetField = thread.getClass().getDeclaredField(fieldName);
targetField.setAccessible(true);
target = targetField.get(thread);
}
catch (Exception localException) {}
}
if ((target != null) && (target.getClass().getClassLoader() == this.loader)) {
return true;
}
return false;
}
private void clearReferencesThreads()
{
Thread[] threads = getThreads();
Thread[] arrayOfThread1;
int j = (arrayOfThread1 = threads).length;
for (int i = 0; i < j; i++)
{
Thread thread = arrayOfThread1[i];
if (thread != null)
{
boolean clear = threadNeedClear(thread);
if (clear) {
if (thread.getClass().getName().startsWith("java.util.Timer"))
{
clearReferencesStopTimerThread(thread);
}
else
{
try
{
Object target = null;
String[] arrayOfString;
int m = (arrayOfString = new String[] { "target", "runnable", "action" }).length;
for (int k = 0; k < m; k++)
{
String fieldName = arrayOfString[k];
try
{
Field targetField = thread.getClass().getDeclaredField(fieldName);
targetField.setAccessible(true);
target = targetField.get(thread);
}
catch (NoSuchFieldException localNoSuchFieldException) {}
}
if ((target != null) &&
(target.getClass().getCanonicalName() != null) &&
(target.getClass().getCanonicalName().equals("java.util.concurrent.ThreadPoolExecutor.Worker")))
{
Field executorField = target.getClass().getDeclaredField("this$0");
executorField.setAccessible(true);
Object executor = executorField.get(target);
if ((executor instanceof ThreadPoolExecutor)) {
((ThreadPoolExecutor)executor).shutdownNow();
}
}
}
catch (Exception e)
{
e.printStackTrace();
}
try
{
thread.notifyAll();
thread.interrupt();
}
catch (Throwable localThrowable) {}
try
{
thread.stop();
}
catch (Throwable localThrowable1) {}
}
}
}
}
}
private void clearReferencesStopTimerThread(Thread thread)
{
try
{
try
{
Field newTasksMayBeScheduledField = thread.getClass().getDeclaredField("newTasksMayBeScheduled");
newTasksMayBeScheduledField.setAccessible(true);
Field queueField = thread.getClass().getDeclaredField("queue");
queueField.setAccessible(true);
Object queue = queueField.get(thread);
Method clearMethod = queue.getClass().getDeclaredMethod("clear", new Class[0]);
clearMethod.setAccessible(true);
synchronized (queue)
{
newTasksMayBeScheduledField.setBoolean(thread, false);
clearMethod.invoke(queue, new Object[0]);
queue.notify();
}
}
catch (NoSuchFieldException nfe)
{
Method cancelMethod = thread.getClass().getDeclaredMethod("cancel", new Class[0]);
synchronized (thread)
{
cancelMethod.setAccessible(true);
cancelMethod.invoke(thread, new Object[0]);
}
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
private void clearReferencesThreadLocals()
{
Thread[] threads = getThreads();
try
{
Field threadLocalsField = Thread.class.getDeclaredField("threadLocals");
threadLocalsField.setAccessible(true);
Field inheritableThreadLocalsField = Thread.class.getDeclaredField("inheritableThreadLocals");
inheritableThreadLocalsField.setAccessible(true);
Class tlmClass = Class.forName("java.lang.ThreadLocal$ThreadLocalMap");
Field tableField = tlmClass.getDeclaredField("table");
tableField.setAccessible(true);
Method expungeStaleEntriesMethod = tlmClass.getDeclaredMethod("expungeStaleEntries", new Class[0]);
expungeStaleEntriesMethod.setAccessible(true);
for (int i = 0; i < threads.length; i++) {
if (threads[i] != null)
{
Object threadLocalMap = threadLocalsField.get(threads[i]);
if (threadLocalMap != null)
{
expungeStaleEntriesMethod.invoke(threadLocalMap, new Object[0]);
checkThreadLocalMapForLeaks(threadLocalMap, tableField);
}
threadLocalMap = inheritableThreadLocalsField.get(threads[i]);
if (threadLocalMap != null)
{
expungeStaleEntriesMethod.invoke(threadLocalMap, new Object[0]);
checkThreadLocalMapForLeaks(threadLocalMap, tableField);
}
}
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
private void checkThreadLocalMapForLeaks(Object map, Field internalTableField)
throws NoSuchMethodException, IllegalAccessException, NoSuchFieldException, InvocationTargetException
{
if (map != null)
{
Method mapRemove = map.getClass().getDeclaredMethod("remove", new Class[] { ThreadLocal.class });
mapRemove.setAccessible(true);
Object[] table = (Object[])internalTableField.get(map);
int staleEntriesCount = 0;
if (table != null) {
for (int j = 0; j < table.length; j++) {
if (table[j] != null)
{
boolean remove = false;
Object key = ((Reference)table[j]).get();
if ((equals(key)) || (isLoadedByThisWebappClassLoader(key))) {
remove = true;
}
Field valueField = table[j].getClass().getDeclaredField("value");
valueField.setAccessible(true);
Object value = valueField.get(table[j]);
if ((equals(value)) || (isLoadedByThisWebappClassLoader(value))) {
remove = true;
}
if (remove) {
if (key == null) {
staleEntriesCount++;
} else {
mapRemove.invoke(map, new Object[] { key });
}
}
}
}
}
if (staleEntriesCount > 0)
{
Method mapRemoveStale = map.getClass().getDeclaredMethod("expungeStaleEntries", new Class[0]);
mapRemoveStale.setAccessible(true);
mapRemoveStale.invoke(map, new Object[0]);
}
}
}
private boolean isLoadedByThisWebappClassLoader(Object o)
{
if (o == null) {
return false;
}
for (ClassLoader loader = o.getClass().getClassLoader(); loader != null; loader = loader.getParent()) {
if (loader == this.loader) {
return true;
}
}
return false;
}
private Thread[] getThreads()
{
ThreadGroup tg = Thread.currentThread().getThreadGroup();
while (tg.getParent() != null) {
tg = tg.getParent();
}
int threadCountGuess = tg.activeCount() + 50;
Thread[] threads = new Thread[threadCountGuess];
int threadCountActual = tg.enumerate(threads);
while (threadCountActual == threadCountGuess)
{
threadCountGuess *= 2;
threads = new Thread[threadCountGuess];
threadCountActual = tg.enumerate(threads);
}
return threads;
}
private void clearReferencesRmiTargets()
{
try
{
Class objectTargetClass = Class.forName("sun.rmi.transport.Target");
Field cclField = objectTargetClass.getDeclaredField("ccl");
cclField.setAccessible(true);
Class objectTableClass = Class.forName("sun.rmi.transport.ObjectTable");
Field objTableField = objectTableClass.getDeclaredField("objTable");
objTableField.setAccessible(true);
Object objTable = objTableField.get(null);
if (objTable == null) {
return;
}
if ((objTable instanceof Map))
{
Iterator iter = ((Map)objTable).values().iterator();
while (iter.hasNext())
{
Object obj = iter.next();
Object cclObject = cclField.get(obj);
if (this == cclObject) {
iter.remove();
}
}
}
Field implTableField = objectTableClass.getDeclaredField("implTable");
implTableField.setAccessible(true);
Object implTable = implTableField.get(null);
if (implTable == null) {
return;
}
if ((implTable instanceof Map))
{
Iterator iter = ((Map)implTable).values().iterator();
while (iter.hasNext())
{
Object obj = iter.next();
Object cclObject = cclField.get(obj);
if (this == cclObject) {
iter.remove();
}
}
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
private void clearReferencesResourceBundles()
{
try
{
Field cacheListField = ResourceBundle.class.getDeclaredField("cacheList");
cacheListField.setAccessible(true);
Map cacheList = (Map)cacheListField.get(null);
Set keys = cacheList.keySet();
Field loaderRefField = null;
Iterator keysIter = keys.iterator();
while (keysIter.hasNext())
{
Object key = keysIter.next();
if (loaderRefField == null)
{
loaderRefField = key.getClass().getDeclaredField("loaderRef");
loaderRefField.setAccessible(true);
}
WeakReference loaderRef = (WeakReference)loaderRefField.get(key);
ClassLoader loader = (ClassLoader)loaderRef.get();
while ((loader != null) && (loader != this.loader)) {
loader = loader.getParent();
}
if (loader != null) {
keysIter.remove();
}
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
