KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > mina > integration > spring > ThreadPoolExecutorFactoryBean


1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one
3  * or more contributor license agreements. See the NOTICE file
4  * distributed with this work for additional information
5  * regarding copyright ownership. The ASF licenses this file
6  * to you under the Apache License, Version 2.0 (the
7  * "License"); you may not use this file except in compliance
8  * with the License. You may obtain a copy of the License at
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing,
13  * software distributed under the License is distributed on an
14  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15  * KIND, either express or implied. See the License for the
16  * specific language governing permissions and limitations
17  * under the License.
18  *
19  */
20 package org.apache.mina.integration.spring;
21
22 import org.springframework.beans.factory.FactoryBean;
23 import org.springframework.beans.factory.config.AbstractFactoryBean;
24
25 import java.util.concurrent.BlockingQueue JavaDoc;
26 import java.util.concurrent.Executors JavaDoc;
27 import java.util.concurrent.LinkedBlockingQueue JavaDoc;
28 import java.util.concurrent.RejectedExecutionHandler JavaDoc;
29 import java.util.concurrent.SynchronousQueue JavaDoc;
30 import java.util.concurrent.ThreadFactory JavaDoc;
31 import java.util.concurrent.ThreadPoolExecutor JavaDoc;
32 import java.util.concurrent.TimeUnit JavaDoc;
33
34 /**
35  * Spring {@link FactoryBean} which enables the configuration of
36  * {@link ThreadPoolExecutor} instances using Spring. Most of this code
37  * has been copied from the <code>ThreadPoolTaskExecutor</code> class
38  * available in Spring 2.0.
39  *
40  * @author The Apache Directory Project (mina-dev@directory.apache.org)
41  * @version $Rev$, $Date$
42  */
43 public class ThreadPoolExecutorFactoryBean extends AbstractFactoryBean {
44     private int corePoolSize = 1;
45
46     private int maxPoolSize = Integer.MAX_VALUE;
47
48     private int keepAliveSeconds = 60;
49
50     private int queueCapacity = Integer.MAX_VALUE;
51
52     private ThreadFactory JavaDoc threadFactory = Executors.defaultThreadFactory();
53
54     private RejectedExecutionHandler JavaDoc rejectedExecutionHandler = new ThreadPoolExecutor.AbortPolicy JavaDoc();
55
56     /**
57      * Set the ThreadPoolExecutor's core pool size. Default is 1.
58      */
59     public void setCorePoolSize(int corePoolSize) {
60         this.corePoolSize = corePoolSize;
61     }
62
63     /**
64      * Set the ThreadPoolExecutor's maximum pool size. Default is
65      * <code>Integer.MAX_VALUE</code>.
66      */
67     public void setMaxPoolSize(int maxPoolSize) {
68         this.maxPoolSize = maxPoolSize;
69     }
70
71     /**
72      * Set the ThreadPoolExecutor's keep alive seconds. Default is 60.
73      */
74     public void setKeepAliveSeconds(int keepAliveSeconds) {
75         this.keepAliveSeconds = keepAliveSeconds;
76     }
77
78     /**
79      * Set the capacity for the ThreadPoolExecutor's BlockingQueue. Default is
80      * <code>Integer.MAX_VALUE</code>.
81      * <p>
82      * Any positive value will lead to a LinkedBlockingQueue instance; any other
83      * value will lead to a SynchronousQueue instance.
84      *
85      * @see LinkedBlockingQueue
86      * @see SynchronousQueue
87      */
88     public void setQueueCapacity(int queueCapacity) {
89         this.queueCapacity = queueCapacity;
90     }
91
92     /**
93      * Set the ThreadFactory to use for the ThreadPoolExecutor's thread pool.
94      * Default is the ThreadPoolExecutor's default thread factory.
95      *
96      * @see Executors#defaultThreadFactory()
97      */
98     public void setThreadFactory(ThreadFactory JavaDoc threadFactory) {
99         this.threadFactory = (threadFactory != null ? threadFactory : Executors
100                 .defaultThreadFactory());
101     }
102
103     /**
104      * Set the RejectedExecutionHandler to use for the ThreadPoolExecutor.
105      * Default is the ThreadPoolExecutor's default abort policy.
106      *
107      * @see ThreadPoolExecutor.AbortPolicy
108      */
109     public void setRejectedExecutionHandler(
110             RejectedExecutionHandler JavaDoc rejectedExecutionHandler) {
111         this.rejectedExecutionHandler = (rejectedExecutionHandler != null ? rejectedExecutionHandler
112                 : new ThreadPoolExecutor.AbortPolicy JavaDoc());
113     }
114
115     protected Object JavaDoc createInstance() throws Exception JavaDoc {
116         BlockingQueue JavaDoc<Runnable JavaDoc> queue = null;
117         if (queueCapacity > 0) {
118             queue = new LinkedBlockingQueue JavaDoc<Runnable JavaDoc>(queueCapacity);
119         } else {
120             queue = new SynchronousQueue JavaDoc<Runnable JavaDoc>();
121         }
122         return new ThreadPoolExecutor JavaDoc(corePoolSize, maxPoolSize,
123                 keepAliveSeconds, TimeUnit.SECONDS, queue, threadFactory,
124                 rejectedExecutionHandler);
125     }
126
127     protected void destroyInstance(Object JavaDoc o) throws Exception JavaDoc {
128         ThreadPoolExecutor JavaDoc executor = (ThreadPoolExecutor JavaDoc) o;
129         executor.shutdown();
130     }
131
132     public Class JavaDoc getObjectType() {
133         return ThreadPoolExecutor JavaDoc.class;
134     }
135
136 }
137
Popular Tags