Reuse database connection without leading to memory leak

Let me just describe the whole situation before I talk about my problem.

We developed a software that connects to a database (MySQL) through a very, very slow connection (There is nothing that can be done to increase the connection speed).

Knowing that the connection is slow, we created a class (Singleton) that handles all MySQL queries and that reuses the Connection.
The way it is done can be seen in the code snippet. There is one method (getStatement) that tries to ask the current Connection for a statement. If that fails (the connection is gone) it reconnects to the database before returning the statement.

This technique worked very well and we were able to reduce the queries delay significantly. But then came our current problem:
The software had a memory leak that caused it to consume all available heap space in a couple of hours.

After investigation we discovered that even though there are no references to the Statement or ResultSet objects, the Garbage Collector does not purge them until the connection is closed ...
To test this theory we closed the connection after each use (as seen on the code snippet) and the memory leak was gone.

Finally, my question:
- Is there a way to free the results of a query (Statement and ResultSet) without closing the connection?
- Is there another way to do achieve this goal (reduce the connection overhead) without these consequences (memory leak)?

Thanks in advanceStart Free Trial

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

public ResultSet selectQuery(String sql){
		Statement ts = getStatement();
		if(ts == null) return null;
		try {
			ResultSet res = ts.executeQuery(sql);
			
			lc.close(); // ADDED LATER!!! 
			return res;
		} catch (SQLException e) {
			if(debug) e.printStackTrace();
			return null;
		} catch (Exception ee){ // ADDED LATER!!!
			return null;
		}
	}