How to avoid memory leak at ShutdownThread using Jetty 9 WebSocketClient - memory-leaks

Question

We have a tool using Jetty WebSocketClient to connect to a server. We need to restart the connection to the server sometimes.
With the current code we run into memory leak at org.eclipse.jetty.util.thread.ShutdownThread, where all used instances of org.eclipse.jetty.websocket.client.WebSocketClient are kept.
As in the documentation at http://www.eclipse.org/jetty/documentation/current/jetty-websocket-client-api.html the only thing to do, is to call client.stop().
Is there some issue with the code or with Jetty itself?
The following is a "minimal" example of the code. Where the main runs a "test" where the consumed memory is tracked and compared.
The result is: more heap used: 97 / 100 - telling me that something is wrong...
Task handles the connection to the server (and would keep additional info):
package example;
import java.io.IOException;
import java.net.URI;
import org.eclipse.jetty.websocket.client.ClientUpgradeRequest;
import org.eclipse.jetty.websocket.client.WebSocketClient;
class Task {
public enum StopReason {
CLOSED,
EXIT,
RESTART
}
private WebSocketClient client;
private ClientSocket socket;
private URI uri;
public Task(URI uri) {
this.uri = uri;
}
public void restart() throws IOException {
System.out.println("Task.restart");
stop(StopReason.RESTART);
synchronized (this) {
try {
this.wait(10);
} catch (InterruptedException e) {
// ignore
}
}
start();
}
public void start() throws IOException {
System.out.println("Task.start");
client = new WebSocketClient();
client.getPolicy().setIdleTimeout(120000);
client.setMaxIdleTimeout(1000);
socket = new ClientSocket(this);
try {
client.start();
System.out.println("Task started");
} catch (Exception e) {
throw new IOException("Failed to start WebSocketClient: " + e.getLocalizedMessage(), e);
}
ClientUpgradeRequest request = new ClientUpgradeRequest();
request.setRequestURI(uri);
client.connect(socket, request.getRequestURI(), request);
System.out.println("Task connected");
}
public void stop(Task.StopReason stopReason) throws IOException {
System.out.println("Task.stop " + stopReason);
if (stopReason != StopReason.CLOSED) {
try {
client.stop();
} catch (Exception e) {
throw new IOException("Task Error at 'stop': " + e.getLocalizedMessage(), e);
}
client.destroy();
try {
client.getConnectionManager().stop();
} catch (Exception e) {
System.err.println("Task Error at 'stop': " + e.getLocalizedMessage());
}
client.getConnectionManager().destroy();
}
System.out.println("Task.stop done " + stopReason);
}
}
main class to run the "test":
package example;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Collections;
import java.util.Map;
import javax.websocket.DeploymentException;
import javax.websocket.server.ServerEndpoint;
import org.glassfish.tyrus.server.Server;
import example.Task.StopReason;
#SuppressWarnings("javadoc")
#ServerEndpoint(value = "/test")
public class MemoryLeakDebug {
public static void main(String[] args) throws IOException, URISyntaxException, DeploymentException {
Map<String, Object> config = Collections.emptyMap();
Server server = new Server("localhost", 10000, "/test", config, DummyEndpoint.class);
server.start();
Task task = new Task(new URI("ws://localhost:10000/test/test"));
task.start();
long[] useds = new long[100];
try {
for (int i = 0; i < useds.length; i++) {
System.out.println("------------------------");
Runtime.getRuntime().gc();
long used = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
System.out.println("used: " + used);
useds[i] = used;
task.restart();
synchronized (task) {
try {
task.wait(100);
} catch (InterruptedException e) {
System.err.println(e.getLocalizedMessage());
}
}
}
} catch (AssertionError e) {
throw e;
} finally {
task.stop(StopReason.EXIT);
server.stop();
StringBuilder sb = new StringBuilder("useds:\n");
int index = 0;
int count = 0;
int moreCount = 0;
long last = -1;
for (long used : useds) {
sb.append((index++) + "\t" + used + "\n");
if (used > 0) {
count++;
}
if (last != -1) {
if (used > last) {
moreCount++;
}
}
last = used;
}
System.out.println(sb.toString());
System.out.println(moreCount + " / " + count);
if (moreCount > count * .75) {
throw new IllegalStateException("more heap used: " + moreCount + " / " + count);
}
}
}
}
Mock endpoint:
package example;
import javax.websocket.CloseReason;
import javax.websocket.EndpointConfig;
import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
#SuppressWarnings("javadoc")
#ServerEndpoint(value = "/test")
public class DummyEndpoint {
public DummyEndpoint() {
System.out.println("DummyEndpoint");
}
#OnClose
public void handleOnClose(Session session, CloseReason reason) {
System.out.println("DummyEndpoint#OnClose: " + reason + " " + session);
}
#OnError
public void handleOnError(Session session, Throwable error) {
System.out.println("DummyEndpoint#OnError: " + error + " " + session + " " + error.toString());
}
#OnMessage
public void handleOnMessage(Session session, String message) {
System.out.println("DummyEndpoint#OnMessage: " + message + " " + session);
}
#OnOpen
public void handleOnOpen(final Session session, EndpointConfig conf) {
System.out.println("DummyEndpoint#OnOpen: " + conf + " " + session);
}
}
Simplified dummy client:
package example;
import java.io.IOException;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketError;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
import org.eclipse.jetty.websocket.api.annotations.WebSocket;
import example.Task.StopReason;
#SuppressWarnings("javadoc")
#WebSocket
public class ClientSocket {
private Session session;
private Task task;
public ClientSocket(Task task) {
this.task = task;
}
#OnWebSocketClose
public void handleClose(int statusCode, String reason) {
System.out.println("ClientSocket#OnWebSocketClose " + statusCode + " " + reason);
session = null;
try {
task.stop(StopReason.CLOSED);
} catch (IOException e) {
throw new IllegalStateException("Error at 'handleClose': " + e.getLocalizedMessage(), e);
}
}
#OnWebSocketConnect
public void handleConnect(Session session) {
System.out.println("ClientSocket#OnWebSocketConnect " + session);
this.session = session;
}
#OnWebSocketError
public void handleError(Throwable cause) {
System.err.println("ClientSocket#OnError" + cause);
cause.printStackTrace();
}
#OnWebSocketMessage
public void handleMessage(String message) {
System.out.println("ClientSocket#OnWebSocketMessage " + message);
}
public boolean isConnected() {
return session != null;
}
}
Our dependencies:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>example</groupId>
<artifactId>WebSocketClientDebug</artifactId>
<version>0.1.0-SNAPSHOT</version>
<properties>
<tyrus-version>[1.8.3,1.9)</tyrus-version>
</properties>
<dependencies>
<!-- + + + + + external dependencies + + + + + -->
<dependency>
<groupId>org.eclipse.jetty.websocket</groupId>
<artifactId>websocket-client</artifactId>
<version>9.2.3.v20140905</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>[2.6.0,3.2.0)</version>
</dependency>
<!-- + + + + + external test dependencies + + + + + -->
<dependency>
<groupId>org.glassfish.tyrus</groupId>
<artifactId>tyrus-client</artifactId>
<version>[1.8.3,1.9)</version>
</dependency>
<dependency>
<groupId>org.glassfish.tyrus</groupId>
<artifactId>tyrus-container-grizzly-server</artifactId>
<version>${tyrus-version}</version>
</dependency>
<dependency>
<groupId>org.glassfish.tyrus</groupId>
<artifactId>tyrus-server</artifactId>
<version>${tyrus-version}</version>
</dependency>
<dependency>
<groupId>org.glassfish.tyrus</groupId>
<artifactId>tyrus-container-grizzly-client</artifactId>
<version>${tyrus-version}</version>
</dependency>
</dependencies>
</project>

Answer 1

This was a bug in Jetty's WebSocketClient behavior.
See https://bugs.eclipse.org/bugs/show_bug.cgi?id=444748
This fix is in for Jetty 9.2.4 (currently staged, being tested, and due for a release in the next 7 days)
Contact me on irc.freenode.net/#jetty if you want to access to this staged version, or just wait for it to be released.