net.sf.ehcache.constructs.nonstop.util.CountingThreadFactory Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of ehcache Show documentation

Ehcache is an open source, standards-based cache used to boost performance, offload the database and simplify scalability. Ehcache is robust, proven and full-featured and this has made it the most widely-used Java-based cache.

There is a newer version: 2.10.9.2

Show newest version

/**
 *  Copyright Terracotta, Inc.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package net.sf.ehcache.constructs.nonstop.util;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * A custom {@link ThreadFactory} that maintains a count of how many threads this factory has created
 *
 * @author Abhishek Sanoujam
 *
 */
public class CountingThreadFactory implements ThreadFactory {

    private final AtomicInteger count = new AtomicInteger();
    private final ThreadFactory actualFactory;

    /**
     * Constructor accepting the actual thread factory that will create the threads
     *
     * @param actualFactory
     *            the actual factory
     */
    public CountingThreadFactory(ThreadFactory actualFactory) {
        this.actualFactory = actualFactory;
    }

    /**
     * {@inheritDoc}
     */
    public Thread newThread(Runnable r) {
        Thread newThread = actualFactory.newThread(new RunnableWithLifeCycle(this, r));
        if (newThread != null) {
            count.incrementAndGet();
        }
        return newThread;
    }

    /**
     * Returns the number of threads this factory has created and currently alive
     *
     * @return Returns the number of threads this factory has created and currently alive
     */
    public int getNumberOfThreads() {
        return count.get();
    }

    private void threadExecutionComplete() {
        count.decrementAndGet();
    }

    /**
     * Runnable which also fires lifecycle events
     *
     * @author Abhishek Sanoujam
     *
     */
    private static class RunnableWithLifeCycle implements Runnable {

        private final Runnable actualRunnable;
        private final CountingThreadFactory countingThreadFactory;

        /**
         * Constructor accepting a {@link CountingThreadFactory} and the actual runnable
         *
         * @param countingThreadFactory
         * @param actualRunnable
         */
        public RunnableWithLifeCycle(CountingThreadFactory countingThreadFactory, Runnable actualRunnable) {
            super();
            this.countingThreadFactory = countingThreadFactory;
            this.actualRunnable = actualRunnable;
        }

        /**
         * {@inheritDoc}
         */
        public void run() {
            try {
                if (actualRunnable != null) {
                    actualRunnable.run();
                }
            } finally {
                countingThreadFactory.threadExecutionComplete();
            }
        }

    }

}