Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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 org.apache.synapse.commons.executors; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.axis2.transport.base.threads.NativeThreadFactory; import java.util.concurrent.*; import java.util.Map; import java.util.HashMap; /** * This is the class used for executing the tasks with a given priority. It is backed by a * BlockingQueue and a ThreadPoolExecutor. The BlockingQueue is a custom implementation which * has multiple internal queues for handling separate priorities. */ public class PriorityExecutor { private final Log log = LogFactory.getLog(PriorityExecutor.class); /** Actual thread pool executor */ private ThreadPoolExecutor executor; /** Name of the executor */ private String name = null; /** Core threads count */ private int core = ExecutorConstants.DEFAULT_CORE; /** Max thread count */ private int max = ExecutorConstants.DEFAULT_MAX; /** Keep alive time for spare threads */ private int keepAlive = ExecutorConstants.DEFAULT_KEEP_ALIVE; /** This will be executed before the Task is submitted */ private BeforeExecuteHandler beforeExecuteHandler; /** Queue used by the executor */ private MultiPriorityBlockingQueue<Runnable> queue; /** this is used by the file based synapse xml configuration */ private String fileName; /** Weather executor is initializer */ private boolean initialzed; /** * Execute a given task with the priority specified. If the task throws an exception, * it will be captured and logged to prevent the threads from dying. * * @param task task to be executed * @param priority priority of the task */ public void execute(final Runnable task, int priority) { if (!initialzed) { throw new IllegalStateException("Executor is not initialized"); } // create a dummy worker to execute the task Worker w = new Worker(task, priority); if (beforeExecuteHandler != null) { beforeExecuteHandler.beforeExecute(w); } // we are capturing all the exceptions to prevent threads from dying executor.execute(w); } /** * Initialize the executor by using the properties. Create the queues * and ThreadPool executor. */ public void init() { if (queue == null) { throw new IllegalStateException("Queue should be specified before initializing"); } executor = new ThreadPoolExecutor(core, max, keepAlive, TimeUnit.SECONDS, queue, new NativeThreadFactory( new ThreadGroup("executor-group"), "priority-worker" + (name != null ? "-" + name : ""))); initialzed = true; if (log.isDebugEnabled()) { log.debug("Started the thread pool executor with threads, " + "core = " + core + " max = " + max + ", keep-alive = " + keepAlive); } } /** * Destroy the executor. Stop all the threads running. */ public void destroy() { if (initialzed) { if (log.isDebugEnabled()) { log.debug("Shutting down priority executor" + (name != null ? ": " + name : "")); } executor.shutdown(); try { executor.awaitTermination(100, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { log.error("Failed to Shut down Executor"); } initialzed = false; } } /** * Set the name of the executor * * @param name of the executor */ public void setName(String name) { this.name = name; } /** * Get the name of the executor * * @return name of the executor */ public String getName() { return name; } /** * Set a handler for execute before putting a worker in to the queues. * User can set some properties to the worker at this point. This * allows users to get more control over the queue selection algorithm. * This is an optional configuration. * * @param beforeExecuteHandler an object implementing the BeforeExecuteHandler */ public void setBeforeExecuteHandler(BeforeExecuteHandler beforeExecuteHandler) { this.beforeExecuteHandler = beforeExecuteHandler; } /** * Get the handler that is executed before the worker is put in to the queue * * @return an object of BeforeExecuteHandler */ public BeforeExecuteHandler getBeforeExecuteHandler() { return beforeExecuteHandler; } /** * Set the queue. * * @param queue queue used for handling the priorities */ public void setQueue(MultiPriorityBlockingQueue<Runnable> queue) { this.queue = queue; } /** * Get the queue. * * @return queue used for handling multiple priorities */ public MultiPriorityBlockingQueue<Runnable> getQueue() { return queue; } /** * Get the core number of threads * * @return core number of threads */ public int getCore() { return core; } /** * Get the max threads * * @return max thread */ public int getMax() { return max; } /** * Get the keep alive time for threads * * @return keep alive time for threads */ public int getKeepAlive() { return keepAlive; } /** * Set the core number of threads * * @param core core number of threads */ public void setCore(int core) { this.core = core; } /** * Set the max number of threads * * @param max max threads */ public void setMax(int max) { this.max = max; } /** * Set the keep alive time for threads * * @param keepAlive keep alive threads */ public void setKeepAlive(int keepAlive) { this.keepAlive = keepAlive; } /** * Get the file used to store this executor config * * @return file used for storing the config */ public String getFileName() { return fileName; } /** * Set the file used to store the config * * @param fileName file name */ public void setFileName(String fileName) { this.fileName = fileName; } /** * Private class for executing the tasks submitted. This class is used for * prevent the threads from dying in case of unhandled exceptions. Also * this class implements the Importance for carrying the priority. */ private class Worker implements Runnable, Importance { private Runnable runnable = null; private Map<String, Object> properties = new HashMap<String, Object>(); private int priority = 1; private Worker(Runnable runnable, int priority) { this.priority = priority; this.runnable = runnable; } public void run() { try { runnable.run(); } catch (Throwable e) { log.error("Unhandled exception", e); } } public int getPriority() { return priority; } public void setPriority(int p) { this.priority = p; } public void setProperty(String name, Object value) { properties.put(name, value); } public Object getProperty(String name) { return properties.get(name); } } }