com.mysql.cj.jdbc.AbandonedConnectionCleanupThread Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of mysql-connector-java
Show all versions of mysql-connector-java
JDBC Type 4 driver for MySQL
/*
* Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License, version 2.0, as published by the
* Free Software Foundation.
*
* This program is also distributed with certain software (including but not
* limited to OpenSSL) that is licensed under separate terms, as designated in a
* particular file or component or in included license documentation. The
* authors of MySQL hereby grant you an additional permission to link the
* program and your derivative works with the separately licensed software that
* they have included with MySQL.
*
* Without limiting anything contained in the foregoing, this file, which is
* part of MySQL Connector/J, is also subject to the Universal FOSS Exception,
* version 1.0, a copy of which can be found at
* http://oss.oracle.com/licenses/universal-foss-exception.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
* for more details.
*
* You should have received a copy of the GNU General Public License along with
* this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
package com.mysql.cj.jdbc;
import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import com.mysql.cj.MysqlConnection;
import com.mysql.cj.protocol.NetworkResources;
/**
* This class implements a thread that is responsible for closing abandoned MySQL connections, i.e., connections that are not explicitly closed.
* There is only one instance of this class and there is a single thread to do this task. This thread's executor is statically referenced in this same class.
*/
public class AbandonedConnectionCleanupThread implements Runnable {
private static final Set connectionFinalizerPhantomRefs = ConcurrentHashMap.newKeySet();
private static final ReferenceQueue referenceQueue = new ReferenceQueue<>();
private static final ExecutorService cleanupThreadExcecutorService;
private static Thread threadRef = null;
private static Lock threadRefLock = new ReentrantLock();
static {
cleanupThreadExcecutorService = Executors.newSingleThreadExecutor(r -> {
Thread t = new Thread(r, "mysql-cj-abandoned-connection-cleanup");
t.setDaemon(true);
// Tie the thread's context ClassLoader to the ClassLoader that loaded the class instead of inheriting the context ClassLoader from the current
// thread, which would happen by default.
// Application servers may use this information if they attempt to shutdown this thread. By leaving the default context ClassLoader this thread
// could end up being shut down even when it is shared by other applications and, being it statically initialized, thus, never restarted again.
ClassLoader classLoader = AbandonedConnectionCleanupThread.class.getClassLoader();
if (classLoader == null) {
// This class was loaded by the Bootstrap ClassLoader, so lets tie the thread's context ClassLoader to the System ClassLoader instead.
classLoader = ClassLoader.getSystemClassLoader();
}
t.setContextClassLoader(classLoader);
return threadRef = t;
});
cleanupThreadExcecutorService.execute(new AbandonedConnectionCleanupThread());
}
private AbandonedConnectionCleanupThread() {
}
public void run() {
for (;;) {
try {
checkThreadContextClassLoader();
Reference reference = referenceQueue.remove(5000);
if (reference != null) {
finalizeResource((ConnectionFinalizerPhantomReference) reference);
}
} catch (InterruptedException e) {
threadRefLock.lock();
try {
threadRef = null;
// Finalize remaining references.
Reference reference;
while ((reference = referenceQueue.poll()) != null) {
finalizeResource((ConnectionFinalizerPhantomReference) reference);
}
connectionFinalizerPhantomRefs.clear();
} finally {
threadRefLock.unlock();
}
return;
} catch (Exception ex) {
// Nowhere to really log this.
}
}
}
/**
* Checks if the thread's context ClassLoader is active. This is usually true but some application managers implement a life-cycle mechanism in their
* ClassLoaders that is linked to the corresponding application's life-cycle. As such, a stopped/ended application will have a ClassLoader unable to load
* anything and, eventually, they throw an exception when trying to do so. When this happens, this thread has no point in being alive anymore.
*/
private void checkThreadContextClassLoader() {
try {
threadRef.getContextClassLoader().getResource("");
} catch (Throwable e) {
// Shutdown no matter what.
uncheckedShutdown();
}
}
/**
* Checks if the context ClassLoaders from this and the caller thread are the same.
*
* @return true if both threads share the same context ClassLoader, false otherwise
*/
private static boolean consistentClassLoaders() {
threadRefLock.lock();
try {
if (threadRef == null) {
return false;
}
ClassLoader callerCtxClassLoader = Thread.currentThread().getContextClassLoader();
ClassLoader threadCtxClassLoader = threadRef.getContextClassLoader();
return callerCtxClassLoader != null && threadCtxClassLoader != null && callerCtxClassLoader == threadCtxClassLoader;
} finally {
threadRefLock.unlock();
}
}
/**
* Shuts down this thread either checking or not the context ClassLoaders from the involved threads.
*
* @param checked
* does a checked shutdown if true, unchecked otherwise
*/
private static void shutdown(boolean checked) {
if (checked && !consistentClassLoaders()) {
// This thread can't be shutdown from the current thread's context ClassLoader. Doing so would most probably prevent from restarting this thread
// later on. An unchecked shutdown can still be done if needed by calling shutdown(false).
return;
}
cleanupThreadExcecutorService.shutdownNow();
}
/**
* Performs a checked shutdown, i.e., the context ClassLoaders from this and the caller thread are checked for consistency prior to performing the shutdown
* operation.
*/
public static void checkedShutdown() {
shutdown(true);
}
/**
* Performs an unchecked shutdown, i.e., the shutdown is performed independently of the context ClassLoaders from the involved threads.
*/
public static void uncheckedShutdown() {
shutdown(false);
}
/**
* Returns true if the working thread is alive. It is alive if it was initialized successfully and wasn't shutdown yet.
*
* @return true if the working thread is alive; false otherwise.
*/
public static boolean isAlive() {
threadRefLock.lock();
try {
return threadRef != null && threadRef.isAlive();
} finally {
threadRefLock.unlock();
}
}
/**
* Tracks the finalization of a {@link MysqlConnection} object and keeps a reference to its {@link NetworkResources} so that they can be later released.
*
* @param conn
* the Connection object to track for finalization
* @param io
* the network resources to close on the connection finalization
*/
protected static void trackConnection(MysqlConnection conn, NetworkResources io) {
threadRefLock.lock();
try {
if (isAlive()) {
ConnectionFinalizerPhantomReference reference = new ConnectionFinalizerPhantomReference(conn, io, referenceQueue);
connectionFinalizerPhantomRefs.add(reference);
}
} finally {
threadRefLock.unlock();
}
}
/**
* Release resources from the given {@link ConnectionFinalizerPhantomReference} and remove it from the references set.
*
* @param reference
* the {@link ConnectionFinalizerPhantomReference} to finalize.
*/
private static void finalizeResource(ConnectionFinalizerPhantomReference reference) {
try {
reference.finalizeResources();
reference.clear();
} finally {
connectionFinalizerPhantomRefs.remove(reference);
}
}
/**
* {@link PhantomReference} subclass to track {@link MysqlConnection} objects finalization.
* This class holds a reference to the Connection's {@link NetworkResources} so they it can be later closed.
*/
private static class ConnectionFinalizerPhantomReference extends PhantomReference {
private NetworkResources networkResources;
ConnectionFinalizerPhantomReference(MysqlConnection conn, NetworkResources networkResources, ReferenceQueue refQueue) {
super(conn, refQueue);
this.networkResources = networkResources;
}
void finalizeResources() {
if (this.networkResources != null) {
try {
this.networkResources.forceClose();
} finally {
this.networkResources = null;
}
}
}
}
}