I've found that when using the 2nd level cache with EHCache, it seems to leak one thread for every cached entity and two for the query cache. This is after calling sessionfactory.close(), which is supposed to release all resources relating to the sessionfactory.

Oddly, it is only the threads marked 'Expiry' that leak. Each 'Expiry' thread has a counterpart 'Spool' thread, otherwise named the same. The 'Spool' threads get properly terminated. It's only the 'Expiry' ones that don't get cleaned up. This is, of course, creating a leak every time my servlet context gets reloaded.

In case it makes a difference, EHCache is configured to cache my entities 'eternally'.

Is this a bug in EHCache?

I'm using Hibernate 2.1.1 and whatever version of EHCache comes with.

What ever happened with this? Did it turn out to be an issue?If so what did you do about it?

Still don't know enough about it and haven't looked in to it since. Usually, I restart my container every couple of re-loads anyway, but ya, this shouldn't be happening.

did you open a JIRA?

I will if I can get somebody else to confirm that this is happening with them. Also, is it still happening in Hibernate 3/3.1? I haven't tested that particular problem with it.

I seem to be having same problem with 3.1 beta3.

Debug into org.hibernate.cache.EhCacheProvider.stop() and make sure CacheManager.shutdown() is being executed.

Under what conditions should that method run?

guys, are you calling SessionFactory.close ?

When would I be calling that? I'm running a web app and sessionFactory is a singleton. Basically the use is in the normal spring documented way of using hibernate.

Can you elaborate a bit please? How does that fit into the spring/hibernate scenario?

your application, spring or not, should be calling close() whenever it restarts. close() cleans up resources - and if it is not being called then you have something entirely different than the original poster.

It's a webapp so I almost don't care what happens w restart. Most times we restart we restart the jvm anyway. The only time I would worry about such things is with redeploy which we don't do. Anyway what I am worried about is for a continuously running app. We are seeing a lot more ehcache threads than we should be and this is indicating a thread leak.

public class LocalSessionFactoryBean implements FactoryBean, InitializingBean, DisposableBean {


/**
* Close the SessionFactory on bean factory shutdown.
*/
public void destroy() throws HibernateException {
logger.info("Closing Hibernate SessionFactory");
this.sessionFactory.close();
}


all disposable beans are cleaned up at app close including this one.