org.eclipse.scada.utils.concurrent.CountingThreadPoolExecutor Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.eclipse.scada.utils Show documentation
Utility classes for use throughout the Eclipse SCADA project
The newest version!
/*******************************************************************************
 * Copyright (c) 2006, 2011 TH4 SYSTEMS GmbH and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     TH4 SYSTEMS GmbH - initial API and implementation
 *******************************************************************************/
package org.eclipse.scada.utils.concurrent;

import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class CountingThreadPoolExecutor extends ThreadPoolExecutor
{

    private final static Logger logger = LoggerFactory.getLogger ( CountingThreadPoolExecutor.class );

    public static interface Listener
    {
        public void countChanged ( int count );
    }

    private final Set listeners = new CopyOnWriteArraySet ();

    public CountingThreadPoolExecutor ( final int corePoolSize, final int maximumPoolSize, final long keepAliveTime, final TimeUnit unit, final BlockingQueue workQueue, final RejectedExecutionHandler handler )
    {
        super ( corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler );
    }

    public CountingThreadPoolExecutor ( final int corePoolSize, final int maximumPoolSize, final long keepAliveTime, final TimeUnit unit, final BlockingQueue workQueue, final ThreadFactory threadFactory, final RejectedExecutionHandler handler )
    {
        super ( corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler );
    }

    public CountingThreadPoolExecutor ( final int corePoolSize, final int maximumPoolSize, final long keepAliveTime, final TimeUnit unit, final BlockingQueue workQueue, final ThreadFactory threadFactory )
    {
        super ( corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory );
    }

    public CountingThreadPoolExecutor ( final int corePoolSize, final int maximumPoolSize, final long keepAliveTime, final TimeUnit unit, final BlockingQueue workQueue )
    {
        super ( corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue );
    }

    public void addListener ( final Listener listener )
    {
        this.listeners.add ( listener );
    }

    public void removeListener ( final Listener listener )
    {
        this.listeners.remove ( listener );
    }

    protected void fireCountChanged ( final int count )
    {
        for ( final Listener listener : this.listeners )
        {
            try
            {
                listener.countChanged ( count );
            }
            catch ( final Exception e )
            {
                logger.info ( "Failed to fireCountChanged", e );
            }
        }
    }

    protected void updateCount ()
    {
        fireCountChanged ( getQueue ().size () );
    }

    @Override
    protected void afterExecute ( final Runnable r, final Throwable t )
    {
        super.afterExecute ( r, t );
        updateCount ();
    }

    @Override
    public void shutdown ()
    {
        super.shutdown ();
        updateCount ();
    }

    @Override
    public List shutdownNow ()
    {
        final List result = super.shutdownNow ();
        updateCount ();
        return result;
    }

    @Override
    public boolean remove ( final Runnable task )
    {
        final boolean result = super.remove ( task );
        updateCount ();
        return result;
    }

    @Override
    public Future submit ( final Runnable task )
    {
        final Future result = super.submit ( task );
        updateCount ();
        return result;
    }

    @Override
    public  Future submit ( final Runnable task, final T result )
    {
        final Future resultValue = super.submit ( task, result );
        updateCount ();
        return resultValue;
    }

    @Override
    public  Future submit ( final Callable task )
    {
        final Future result = super.submit ( task );
        updateCount ();
        return result;
    }

    @Override
    public  T invokeAny ( final Collection> tasks ) throws InterruptedException, ExecutionException
    {
        final T result = super.invokeAny ( tasks );
        updateCount ();
        return result;
    }

    @Override
    public  T invokeAny ( final Collection> tasks, final long timeout, final TimeUnit unit ) throws InterruptedException, ExecutionException, TimeoutException
    {
        final T result = super.invokeAny ( tasks, timeout, unit );
        updateCount ();
        return result;
    }

    @Override
    public  List> invokeAll ( final Collection> tasks ) throws InterruptedException
    {
        final List> result = super.invokeAll ( tasks );
        updateCount ();
        return result;
    }

    @Override
    public  List> invokeAll ( final Collection> tasks, final long timeout, final TimeUnit unit ) throws InterruptedException
    {
        final List> result = super.invokeAll ( tasks, timeout, unit );
        updateCount ();
        return result;
    }

    @Override
    public void execute ( final Runnable command )
    {
        super.execute ( command );
        updateCount ();
    }
}