This is an automated email from the ASF dual-hosted git repository. rombert pushed a commit to annotated tag org.apache.sling.commons.threads-2.0.2-incubator in repository https://gitbox.apache.org/repos/asf/sling-org-apache-sling-commons-threads.git
commit cdf45818eca719b0bbc76145a4d5909aa0cda42a Author: Carsten Ziegeler <[email protected]> AuthorDate: Mon Feb 11 11:03:12 2008 +0000 Add new threads module for providing thread pools. git-svn-id: https://svn.apache.org/repos/asf/incubator/sling/trunk/sling/threads@620457 13f79535-47bb-0310-9956-ffa450edef68 --- pom.xml | 85 ++++++++ .../java/org/apache/sling/threads/ThreadPool.java | 42 ++++ .../apache/sling/threads/ThreadPoolManager.java | 40 ++++ .../sling/threads/impl/DefaultThreadFactory.java | 79 +++++++ .../sling/threads/impl/DefaultThreadPool.java | 239 +++++++++++++++++++++ .../threads/impl/DefaultThreadPoolManager.java | 150 +++++++++++++ .../sling/threads/impl/ExtendedThreadFactory.java | 67 ++++++ 7 files changed, 702 insertions(+) diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..5027142 --- /dev/null +++ b/pom.xml @@ -0,0 +1,85 @@ +<?xml version="1.0" encoding="ISO-8859-1"?> +<!-- + 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. +--> +<project xmlns="http://maven.apache.org/POM/4.0.0"; + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"; + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd";> + <modelVersion>4.0.0</modelVersion> + <parent> + <groupId>org.apache.sling</groupId> + <artifactId>sling</artifactId> + <version>1-incubator-SNAPSHOT</version> + <relativePath>../../parent/pom.xml</relativePath> + </parent> + + <artifactId>org.apache.sling.threads</artifactId> + <packaging>bundle</packaging> + <version>2.0.0-incubator-SNAPSHOT</version> + + <name>Sling - Thread Support</name> + <description> + Support for thread handling like pooling. + </description> + + <scm> + <connection> + scm:svn:http://svn.apache.org/repos/asf/incubator/sling/trunk/sling/threads + </connection> + <developerConnection> + scm:svn:https://svn.apache.org/repos/asf/incubator/sling/trunk/sling/threads + </developerConnection> + <url> + http://svn.apache.org/viewvc/incubator/sling/trunk/sling/threads + </url> + </scm> + + <build> + <plugins> + <plugin> + <groupId>org.apache.felix</groupId> + <artifactId>maven-scr-plugin</artifactId> + </plugin> + <plugin> + <groupId>org.apache.felix</groupId> + <artifactId>maven-bundle-plugin</artifactId> + <extensions>true</extensions> + <configuration> + <instructions> + <Export-Package> + org.apache.sling.threads + </Export-Package> + <Private-Package> + org.apache.sling.threads.impl + </Private-Package> + </instructions> + </configuration> + </plugin> + </plugins> + </build> + <dependencies> + <dependency> + <groupId>org.apache.felix</groupId> + <artifactId>org.osgi.compendium</artifactId> + </dependency> + <dependency> + <groupId>org.slf4j</groupId> + <artifactId>slf4j-api</artifactId> + </dependency> + </dependencies> +</project> diff --git a/src/main/java/org/apache/sling/threads/ThreadPool.java b/src/main/java/org/apache/sling/threads/ThreadPool.java new file mode 100644 index 0000000..f10527e --- /dev/null +++ b/src/main/java/org/apache/sling/threads/ThreadPool.java @@ -0,0 +1,42 @@ +/* + * 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.sling.threads; + +/** + * The ThreadPool interface allows to start runnables by + * getting threads from a managed pool. + * + * @version $Id$ + */ +public interface ThreadPool { + + /** + * Execute a runnable + * @param runnable The {@link Runnable} to execute + */ + void execute(Runnable runnable); + + /** + * The name of the thread pool. + */ + String getName(); + + /** + * Shut down the thread pool. + */ + void shutdown(); +} diff --git a/src/main/java/org/apache/sling/threads/ThreadPoolManager.java b/src/main/java/org/apache/sling/threads/ThreadPoolManager.java new file mode 100644 index 0000000..603aa46 --- /dev/null +++ b/src/main/java/org/apache/sling/threads/ThreadPoolManager.java @@ -0,0 +1,40 @@ +/* + * 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.sling.threads; + +/** + * The <cod>ThreadPoolManager</code> manages thread pools. + * + * @version $Id$ + */ +public interface ThreadPoolManager { + + /** + * Add a new pool. + * If a pool with the same name already exists, the new pool is not added + * and false is returned. + * @param pool The pool + * @return True if the pool could be added, false otherwise. + */ + boolean add(ThreadPool pool); + + /** + * Get a thread pool + * @param name The name of the thread pool or null for the default pool. + */ + ThreadPool get(String name); +} diff --git a/src/main/java/org/apache/sling/threads/impl/DefaultThreadFactory.java b/src/main/java/org/apache/sling/threads/impl/DefaultThreadFactory.java new file mode 100644 index 0000000..78a514e --- /dev/null +++ b/src/main/java/org/apache/sling/threads/impl/DefaultThreadFactory.java @@ -0,0 +1,79 @@ +/* + * 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.sling.threads.impl; + + +/** + * This class is responsible to create new Thread instances. + * It's a very basic implementation. + * + * @version $Id$ + */ +public class DefaultThreadFactory + implements ExtendedThreadFactory { + + /** The daemon mode */ + private boolean isDaemon = DefaultThreadPoolManager.DEFAULT_DAEMON_MODE; + + /** The priority of newly created Threads */ + private int priority = DefaultThreadPoolManager.DEFAULT_THREAD_PRIORITY; + + /** + * @see org.apache.sling.threads.impl.ExtendedThreadFactory#setDaemon(boolean) + */ + public void setDaemon( boolean isDaemon ) { + this.isDaemon = isDaemon; + } + + /** + * @see org.apache.sling.threads.impl.ExtendedThreadFactory#isDaemon() + */ + public boolean isDaemon() { + return this.isDaemon; + } + + /** + * @see org.apache.sling.threads.impl.ExtendedThreadFactory#setPriority(int) + */ + public void setPriority( final int priority ) { + if( ( Thread.MAX_PRIORITY == priority ) || + ( Thread.MIN_PRIORITY == priority ) || + ( Thread.NORM_PRIORITY == priority ) ) { + this.priority = priority; + } else { + throw new IllegalStateException("Unknown priority " + this.priority); + } + } + + /** + * @see org.apache.sling.threads.impl.ExtendedThreadFactory#getPriority() + */ + public int getPriority() { + return this.priority; + } + + /** + * @see org.apache.sling.threads.impl.ExtendedThreadFactory#newThread(java.lang.Runnable) + */ + public Thread newThread( final Runnable command ) { + final Thread thread = new Thread( command ); + thread.setPriority( this.priority ); + thread.setDaemon( this.isDaemon ); + + return thread; + } +} diff --git a/src/main/java/org/apache/sling/threads/impl/DefaultThreadPool.java b/src/main/java/org/apache/sling/threads/impl/DefaultThreadPool.java new file mode 100644 index 0000000..c3fb849 --- /dev/null +++ b/src/main/java/org/apache/sling/threads/impl/DefaultThreadPool.java @@ -0,0 +1,239 @@ +/* + * 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.sling.threads.impl; + +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.RejectedExecutionHandler; +import java.util.concurrent.SynchronousQueue; +import java.util.concurrent.ThreadFactory; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +import org.apache.sling.threads.ThreadPool; +import org.apache.sling.threads.ThreadPoolManager; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + +/** + * The DefaultThreadPool class implements the {@link ThreadPool} interface. + * Instances of this class are managed by the {@link ThreadPoolManager}. + * + * @version $Id$ + */ +public class DefaultThreadPool + implements ThreadPool { + + /** By default we use the logger for this class. */ + protected final Logger logger = LoggerFactory.getLogger(this.getClass()); + + /** The name of this thread pool */ + protected final String name; + + /** The executor. */ + protected ThreadPoolExecutor executor; + + /** Should we wait for running jobs to terminate on shutdown ? */ + protected final boolean shutdownGraceful; + + /** How long to wait for running jobs to terminate on disposition */ + protected final int shutdownWaitTimeMs; + + /** + * Create a new thread pool. + * @param name - The name of the thread pool. If null {@link DefaultThreadPoolManager#DEFAULT_THREADPOOL_NAME} + * is used + */ + public DefaultThreadPool(final String name) { + this(DefaultThreadPoolManager.DEFAULT_THREADPOOL_NAME, + DefaultThreadPoolManager.DEFAULT_MIN_POOL_SIZE, + DefaultThreadPoolManager.DEFAULT_MAX_POOL_SIZE, + DefaultThreadPoolManager.DEFAULT_QUEUE_SIZE, + DefaultThreadPoolManager.DEFAULT_KEEP_ALIVE_TIME, + DefaultThreadPoolManager.DEFAULT_BLOCK_POLICY, + DefaultThreadPoolManager.DEFAULT_SHUTDOWN_GRACEFUL, + DefaultThreadPoolManager.DEFAULT_SHUTDOWN_WAIT_TIME, + null, + DefaultThreadPoolManager.DEFAULT_THREAD_PRIORITY, + DefaultThreadPoolManager.DEFAULT_DAEMON_MODE); + } + + /** + * Create a new thread pool. + * @param name - The name of the thread pool. If null {@link DefaultThreadPoolManager#DEFAULT_THREADPOOL_NAME} + * is used + */ + public DefaultThreadPool(final String name, + int minPoolSize, + int maxPoolSize, + final int queueSize, + long keepAliveTime, + String blockPolicy, + final boolean shutdownGraceful, + final int shutdownWaitTimeMs, + final ThreadFactory factory, + final int priority, + final boolean isDaemon) { + this.logger.info("ThreadPool [{}] initializing ...", name); + + // name + if ( name != null ) { + this.name = name; + } else { + this.name = DefaultThreadPoolManager.DEFAULT_THREADPOOL_NAME; + } + + // factory + final ThreadFactory threadFactory; + if (factory == null) { + logger.warn("No ThreadFactory is configured. Will use a " + + DefaultThreadFactory.class.getName()); + threadFactory = new DefaultThreadFactory(); + } else { + threadFactory = factory; + } + + // Min pool size + // make sure we have enough threads for the default thread pool as we + // need one for ourself + if (DefaultThreadPoolManager.DEFAULT_THREADPOOL_NAME.equals(name) + && ((minPoolSize > 0) && (minPoolSize < DefaultThreadPoolManager.DEFAULT_MIN_POOL_SIZE))) { + minPoolSize = DefaultThreadPoolManager.DEFAULT_MIN_POOL_SIZE; + } else if (minPoolSize < 1) { + minPoolSize = 1; + this.logger.warn("min-pool-size < 1 for pool \"" + name + "\". Set to 1"); + } + // Max pool size + maxPoolSize = (maxPoolSize < 0) ? Integer.MAX_VALUE : maxPoolSize; + + // Set priority and daemon if the factory is an extended factory + if ( threadFactory instanceof ExtendedThreadFactory ) { + final ExtendedThreadFactory extTF = (ExtendedThreadFactory)threadFactory; + extTF.setPriority(priority); + extTF.setDaemon(isDaemon); + } else { + if ( priority != Thread.NORM_PRIORITY ) { + this.logger.warn("ThreadFactory " + threadFactory + " does not support setting the priority or daemon setting."); + } + if ( isDaemon != DefaultThreadPoolManager.DEFAULT_DAEMON_MODE ) { + this.logger.warn("ThreadFactory " + threadFactory + " does not support setting the daemon mode."); + } + } + + // Keep alive time + if (keepAliveTime < 0) { + keepAliveTime = 1000; + this.logger.warn("keep-alive-time-ms < 0 for pool \"" + name + "\". Set to 1000"); + } + + // Queue + final BlockingQueue<Runnable> queue; + if (queueSize != 0) { + if (queueSize > 0) { + queue = new java.util.concurrent.ArrayBlockingQueue<Runnable>(queueSize); + } else { + queue = new LinkedBlockingQueue<Runnable>(); + } + } else { + queue = new SynchronousQueue<Runnable>(); + } + + if ( blockPolicy == null ) { + blockPolicy = DefaultThreadPoolManager.DEFAULT_BLOCK_POLICY; + } + final RejectedExecutionHandler handler; + if (DefaultThreadPoolManager.POLICY_ABORT.equalsIgnoreCase(blockPolicy)) { + handler = new ThreadPoolExecutor.AbortPolicy(); + } else if (DefaultThreadPoolManager.POLICY_DISCARD.equalsIgnoreCase(blockPolicy)) { + handler = new ThreadPoolExecutor.AbortPolicy(); + } else if (DefaultThreadPoolManager.POLICY_DISCARD_OLDEST.equalsIgnoreCase(blockPolicy)) { + handler = new ThreadPoolExecutor.AbortPolicy(); + } else if (DefaultThreadPoolManager.POLICY_RUN.equalsIgnoreCase(blockPolicy)) { + handler = new ThreadPoolExecutor.AbortPolicy(); + } else { + final StringBuffer msg = new StringBuffer(); + msg.append("WARNING: Unknown block-policy configuration \"") + .append(blockPolicy); + msg.append("\". Should be one of \"").append(DefaultThreadPoolManager.POLICY_ABORT); + msg.append("\",\"").append(DefaultThreadPoolManager.POLICY_DISCARD); + msg.append("\",\"").append(DefaultThreadPoolManager.POLICY_DISCARD_OLDEST); + msg.append("\",\"").append(DefaultThreadPoolManager.POLICY_RUN); + msg.append("\". Will use \"").append(DefaultThreadPoolManager.DEFAULT_BLOCK_POLICY).append("\""); + logger.warn(msg.toString()); + handler = new ThreadPoolExecutor.CallerRunsPolicy(); + } + this.shutdownGraceful = shutdownGraceful; + this.shutdownWaitTimeMs = shutdownWaitTimeMs; + this.executor = new ThreadPoolExecutor(minPoolSize, + maxPoolSize, + keepAliveTime, + TimeUnit.MILLISECONDS, + queue, + threadFactory, + handler); + this.logger.info("ThreadPool [{}] initialized.", name); + } + + /** + * @see org.apache.sling.threads.ThreadPool#getName() + */ + public String getName() { + return name; + } + + /** + * @see org.apache.sling.threads.ThreadPool#execute(java.lang.Runnable) + */ + public void execute(Runnable runnable) { + if ( this.executor == null ) { + throw new IllegalStateException("Thread pool " + this.name + " is already shutdown."); + } + if ( runnable != null ) { + this.logger.debug("Executing runnable: {},pool={}", runnable, this.name); + + this.executor.execute(runnable); + } + } + + /** + * @see org.apache.sling.threads.ThreadPool#shutdown() + */ + public void shutdown() { + if ( this.executor != null ) { + if (shutdownGraceful) { + this.executor.shutdown(); + } else { + this.executor.shutdownNow(); + } + + try { + if (this.shutdownWaitTimeMs > 0) { + if (!this.executor.awaitTermination(this.shutdownWaitTimeMs, TimeUnit.MILLISECONDS)) { + logger.warn("running commands have not terminated within " + + this.shutdownWaitTimeMs + + "ms. Will shut them down by interruption"); + this.executor.shutdownNow(); + } + } + } catch (final InterruptedException ie) { + this.logger.error("Cannot shutdown ThreadPool", ie); + } + this.executor = null; + } + } +} diff --git a/src/main/java/org/apache/sling/threads/impl/DefaultThreadPoolManager.java b/src/main/java/org/apache/sling/threads/impl/DefaultThreadPoolManager.java new file mode 100644 index 0000000..d122cd3 --- /dev/null +++ b/src/main/java/org/apache/sling/threads/impl/DefaultThreadPoolManager.java @@ -0,0 +1,150 @@ +/* + * 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.sling.threads.impl; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.sling.threads.ThreadPool; +import org.apache.sling.threads.ThreadPoolManager; +import org.osgi.service.component.ComponentContext; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * The DefaultThreadPoolManager implements the {@link ThreadPoolManager} interface + * and is responsible to manage {@link ThreadPool}s. + * + * @scr.component metatype="false" + * @scr.service interface="org.apache.sling.threads.ThreadPoolManager" + * + * @version $Id$ + */ +public class DefaultThreadPoolManager implements ThreadPoolManager { + + /** The default queue size */ + protected final static int DEFAULT_QUEUE_SIZE = -1; + + /** The default maximum pool size */ + protected final static int DEFAULT_MAX_POOL_SIZE = 5; + + /** The default minimum pool size */ + protected final static int DEFAULT_MIN_POOL_SIZE = 5; + + /** The default thread priority */ + protected final static int DEFAULT_THREAD_PRIORITY = Thread.NORM_PRIORITY; + + /** The default daemon mode */ + protected final static boolean DEFAULT_DAEMON_MODE = false; + + /** The default keep alive time */ + protected final static long DEFAULT_KEEP_ALIVE_TIME = 60000L; + + /** The default way to shutdown gracefully */ + protected final static boolean DEFAULT_SHUTDOWN_GRACEFUL = false; + + /** The default shutdown waittime time */ + protected final static int DEFAULT_SHUTDOWN_WAIT_TIME = -1; + + /** The default shutdown waittime time */ + protected final static String DEFAULT_THREADPOOL_NAME = "default"; + + /** ThreadPool block policy ABORT */ + protected final static String POLICY_ABORT = "ABORT"; + + /** ThreadPool block policy DISCARD */ + protected final static String POLICY_DISCARD = "DISCARD"; + + /** ThreadPool block policy DISCARD-OLDEST */ + protected final static String POLICY_DISCARD_OLDEST = "DISCARDOLDEST"; + + /** ThreadPool block policy RUN */ + protected final static String POLICY_RUN = "RUN"; + + /** The default shutdown waittime time */ + protected final static String DEFAULT_BLOCK_POLICY = POLICY_RUN; + + /** By default we use the logger for this class. */ + protected Logger logger = LoggerFactory.getLogger(getClass()); + + /** The managed thread pools */ + protected final Map<String, ThreadPool> pools = new HashMap<String, ThreadPool>(); + + /** + * Activate this component. + */ + protected void activate(ComponentContext context) throws Exception { + this.logger.info("Starting thread pool manager."); + final ThreadPool defaultPool = new DefaultThreadPool( + DEFAULT_THREADPOOL_NAME, + DEFAULT_MIN_POOL_SIZE, + DEFAULT_MAX_POOL_SIZE, + DEFAULT_QUEUE_SIZE, + DEFAULT_KEEP_ALIVE_TIME, + DEFAULT_BLOCK_POLICY, + DEFAULT_SHUTDOWN_GRACEFUL, + DEFAULT_SHUTDOWN_WAIT_TIME, + null, + DEFAULT_THREAD_PRIORITY, + DEFAULT_DAEMON_MODE); + this.pools.put(defaultPool.getName(), defaultPool); + this.logger.info("Thread pool manager startet with default pool."); + } + + /** + * Deactivate this component. + */ + protected void deactivate(ComponentContext context) throws Exception { + this.logger.info("Stopping thread pool manager."); + this.logger.debug("Disposing all thread pools"); + + for (ThreadPool pool : this.pools.values()) { + this.logger.debug("Shutting down thread pool {}", pool.getName()); + + pool.shutdown(); + + this.logger.debug("Thread pool " + pool.getName() + " is shut down."); + } + this.pools.clear(); + this.logger.info("Thread pool manager stopped."); + } + + /** + * @see org.apache.sling.threads.ThreadPoolManager#add(org.apache.sling.threads.ThreadPool) + */ + public boolean add(ThreadPool pool) { + synchronized ( this.pools ) { + if (null != pools.get(pool.getName())) { + return false; + } + pools.put(pool.getName(), pool); + } + return true; + } + + /** + * @see org.apache.sling.threads.ThreadPoolManager#get(java.lang.String) + */ + public ThreadPool get(String name) { + if ( name == null ) { + name = DEFAULT_THREADPOOL_NAME; + } + synchronized (this.pools) { + return this.pools.get(name); + } + } +} diff --git a/src/main/java/org/apache/sling/threads/impl/ExtendedThreadFactory.java b/src/main/java/org/apache/sling/threads/impl/ExtendedThreadFactory.java new file mode 100644 index 0000000..5ad586f --- /dev/null +++ b/src/main/java/org/apache/sling/threads/impl/ExtendedThreadFactory.java @@ -0,0 +1,67 @@ +/* + * 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.sling.threads.impl; + +import java.util.concurrent.ThreadFactory; + +/** + * This is an extension to the {@link ThreadFactory}. + * + * @version $Id$ + */ +public interface ExtendedThreadFactory + extends ThreadFactory { + + /** + * Set the daemon mode of created <code>Thread</code>s should have + * + * @param isDaemon Whether new {@link Thread}s should run as daemons. + */ + void setDaemon( boolean isDaemon ); + + /** + * Get the daemon mode created <code>Thread</code>s will have + * + * @return Whether new {@link Thread}s should run as daemons. + */ + boolean isDaemon(); + + /** + * Set the priority newly created <code>Thread</code>s should have + * + * @param priority One of {@link Thread#MIN_PRIORITY}, {@link + * Thread#NORM_PRIORITY}, {@link Thread#MAX_PRIORITY} + */ + void setPriority( int priority ); + + /** + * Get the priority newly created <code>Thread</code>s will have + * + * @return One of {@link Thread#MIN_PRIORITY}, {@link + * Thread#NORM_PRIORITY}, {@link Thread#MAX_PRIORITY} + */ + int getPriority(); + + /** + * Create a new Thread for a {@link Runnable} command + * + * @param command The <code>Runnable</code> + * + * @return new <code>Thread</code> + */ + Thread newThread( Runnable command ); +} -- To stop receiving notification emails like this one, please contact "[email protected]" <[email protected]>.
