Back to index...
/*
 * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package com.sun.jmx.snmp.tasks;
import java.util.ArrayList;
import com.sun.jmx.snmp.tasks.Task;
import com.sun.jmx.snmp.tasks.TaskServer;
/**
 * This class implements a {@link com.sun.jmx.snmp.tasks.TaskServer} over
 * a thread pool.
 * <p><b>This API is a Sun Microsystems internal API  and is subject
 * to change without notice.</b></p>
 **/
public class ThreadService implements TaskServer {
    public ThreadService(int threadNumber) {
        if (threadNumber <= 0) {
            throw new IllegalArgumentException("The thread number should bigger than zero.");
        }
        minThreads = threadNumber;
        threadList = new ExecutorThread[threadNumber];
        priority = Thread.currentThread().getPriority();
        cloader = Thread.currentThread().getContextClassLoader();
    }
// public methods
// --------------
    /**
     * Submit a task to be executed.
     * Once a task is submitted, it is guaranteed that either
     * {@link com.sun.jmx.snmp.tasks.Task#run() task.run()} or
     * {@link com.sun.jmx.snmp.tasks.Task#cancel() task.cancel()} will be called.
     * This implementation of TaskServer uses a thread pool to execute
     * the submitted tasks.
     * @param task The task to be executed.
     * @exception IllegalArgumentException if the submitted task is null.
     **/
    public void submitTask(Task task) throws IllegalArgumentException {
        submitTask((Runnable)task);
    }
    /**
     * Submit a task to be executed.
     * This implementation of TaskServer uses a thread pool to execute
     * the submitted tasks.
     * @param task The task to be executed.
     * @exception IllegalArgumentException if the submitted task is null.
     **/
    public void submitTask(Runnable task) throws IllegalArgumentException {
        stateCheck();
        if (task == null) {
            throw new IllegalArgumentException("No task specified.");
        }
        synchronized(jobList) {
            jobList.add(jobList.size(), task);
            jobList.notify();
        }
        createThread();
    }
    public Runnable removeTask(Runnable task) {
        stateCheck();
        Runnable removed = null;
        synchronized(jobList) {
            int lg = jobList.indexOf(task);
            if (lg >= 0) {
                removed = jobList.remove(lg);
            }
        }
        if (removed != null && removed instanceof Task)
            ((Task) removed).cancel();
        return removed;
    }
    public void removeAll() {
        stateCheck();
        final Object[] jobs;
        synchronized(jobList) {
            jobs = jobList.toArray();
            jobList.clear();
        }
        final int len = jobs.length;
        for (int i=0; i<len ; i++) {
            final Object o = jobs[i];
            if (o!= null && o instanceof Task) ((Task)o).cancel();
        }
    }
    // to terminate
    public void terminate() {
        if (terminated == true) {
            return;
        }
        terminated = true;
        synchronized(jobList) {
            jobList.notifyAll();
        }
        removeAll();
        for (int i=0; i<currThreds; i++) {
            try {
                threadList[i].interrupt();
            } catch (Exception e) {
                // TODO
            }
        }
        threadList = null;
    }
// private classes
// ---------------
    // A thread used to execute jobs
    //
    private class ExecutorThread extends Thread {
        public ExecutorThread() {
            super(threadGroup, "ThreadService-"+counter++);
            setDaemon(true);
            // init
            this.setPriority(priority);
            this.setContextClassLoader(cloader);
            idle++;
        }
        public void run() {
            while(!terminated) {
                Runnable job = null;
                synchronized(jobList) {
                    if (jobList.size() > 0) {
                        job = jobList.remove(0);
                        if (jobList.size() > 0) {
                            jobList.notify();
                        }
                    } else {
                        try {
                            jobList.wait();
                        } catch (InterruptedException ie) {
                            // terminated ?
                        } finally {
                        }
                        continue;
                    }
                }
                if (job != null) {
                    try {
                        idle--;
                        job.run();
                    } catch (Exception e) {
                        // TODO
                        e.printStackTrace();
                    } finally {
                        idle++;
                    }
                }
                // re-init
                this.setPriority(priority);
                Thread.interrupted();
                this.setContextClassLoader(cloader);
            }
        }
    }
// private methods
    private void stateCheck() throws IllegalStateException {
        if (terminated) {
            throw new IllegalStateException("The thread service has been terminated.");
        }
    }
    private void createThread() {
        if (idle < 1) {
            synchronized(threadList) {
                if (jobList.size() > 0 && currThreds < minThreads) {
                    ExecutorThread et = new ExecutorThread();
                    et.start();
                    threadList[currThreds++] = et;
                }
            }
        }
    }
// protected or private variables
// ------------------------------
    private ArrayList<Runnable> jobList = new ArrayList<Runnable>(0);
    private ExecutorThread[] threadList;
    private int minThreads = 1;
    private int currThreds = 0;
    private int idle = 0;
    private boolean terminated = false;
    private int priority;
    private ThreadGroup threadGroup = new ThreadGroup("ThreadService");
    private ClassLoader cloader;
    private static long counter = 0;
    private int addedJobs = 1;
    private int doneJobs = 1;
}
Back to index...