001: /*
002: * Distributed as part of c3p0 v.0.9.1.2
003: *
004: * Copyright (C) 2005 Machinery For Change, Inc.
005: *
006: * Author: Steve Waldman <swaldman@mchange.com>
007: *
008: * This library is free software; you can redistribute it and/or modify
009: * it under the terms of the GNU Lesser General Public License version 2.1, as
010: * published by the Free Software Foundation.
011: *
012: * This software is distributed in the hope that it will be useful,
013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
015: * GNU Lesser General Public License for more details.
016: *
017: * You should have received a copy of the GNU Lesser General Public License
018: * along with this software; see the file LICENSE. If not, write to the
019: * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
020: * Boston, MA 02111-1307, USA.
021: */
022:
023: package com.mchange.v2.resourcepool;
024:
025: import java.util.Timer;
026: import com.mchange.v2.async.*;
027:
028: /**
029: * <P>A Factory for ResourcePools. ResourcePoolFactories may manage
030: * resources (usually threads that perform maintenance tasks) that
031: * are shared by all pools that they create. Clients who require
032: * a large number of pools may wish to create their own factory
033: * instances rather than using the shared instance to control
034: * the degree of resource (Thread) sharing among pools.</P>
035: *
036: * <P>Factories should (and the default implementation does) be careful
037: * to ensure that factories keep resources open only while there
038: * are active ResourcePools that they have created.</P>
039: *
040: * <P>Subclasses must mark all methods synchronized so that clients
041: * may reliably use shared factories to do stuff like...</P>
042: *
043: * <pre>
044: * synchronized (factory)
045: * {
046: * factory.setMin(8);
047: * factory.setMax(24);
048: * ResourcePool rp = factory.createPool();
049: * }
050: * </pre>
051: */
052: public abstract class ResourcePoolFactory {
053: // okay, 'cuz we don't actually create any threads / resourced
054: // until the factory is used.
055: final static ResourcePoolFactory SHARED_INSTANCE = new BasicResourcePoolFactory();
056:
057: final static int DEFAULT_NUM_TASK_THREADS = 3;
058:
059: public static ResourcePoolFactory getSharedInstance()
060: throws ResourcePoolException {
061: return SHARED_INSTANCE;
062: }
063:
064: public static ResourcePoolFactory createInstance() {
065: return new BasicResourcePoolFactory();
066: }
067:
068: public static ResourcePoolFactory createInstance(
069: int num_task_threads) {
070: return new BasicResourcePoolFactory(num_task_threads);
071: }
072:
073: /**
074: * Any or all of these arguments can be null -- any unspecified resources
075: * will be created and cleaned up internally.
076: */
077: public static ResourcePoolFactory createInstance(
078: AsynchronousRunner taskRunner,
079: RunnableQueue asyncEventQueue, Timer cullTimer) {
080: return new BasicResourcePoolFactory(taskRunner,
081: asyncEventQueue, cullTimer);
082: }
083:
084: public static ResourcePoolFactory createInstance(
085: Queuable taskRunnerEventQueue, Timer cullTimer) {
086: return createInstance(taskRunnerEventQueue,
087: taskRunnerEventQueue == null ? null
088: : taskRunnerEventQueue.asRunnableQueue(),
089: cullTimer);
090: }
091:
092: public abstract void setMin(int min) throws ResourcePoolException;
093:
094: public abstract int getMin() throws ResourcePoolException;
095:
096: public abstract void setMax(int max) throws ResourcePoolException;
097:
098: public abstract int getStart() throws ResourcePoolException;
099:
100: public abstract void setStart(int start)
101: throws ResourcePoolException;
102:
103: public abstract int getMax() throws ResourcePoolException;
104:
105: public abstract void setIncrement(int max)
106: throws ResourcePoolException;
107:
108: public abstract int getIncrement() throws ResourcePoolException;
109:
110: public abstract void setAcquisitionRetryAttempts(int retry_attempts)
111: throws ResourcePoolException;
112:
113: public abstract int getAcquisitionRetryAttempts()
114: throws ResourcePoolException;
115:
116: public abstract void setAcquisitionRetryDelay(int retry_delay)
117: throws ResourcePoolException;
118:
119: public abstract int getAcquisitionRetryDelay()
120: throws ResourcePoolException;
121:
122: public abstract void setIdleResourceTestPeriod(long test_period)
123: throws ResourcePoolException;
124:
125: public abstract long getIdleResourceTestPeriod()
126: throws ResourcePoolException;
127:
128: public abstract void setResourceMaxAge(long millis)
129: throws ResourcePoolException;
130:
131: public abstract long getResourceMaxAge()
132: throws ResourcePoolException;
133:
134: public abstract void setResourceMaxIdleTime(long millis)
135: throws ResourcePoolException;
136:
137: public abstract long getResourceMaxIdleTime()
138: throws ResourcePoolException;
139:
140: public abstract void setExcessResourceMaxIdleTime(long millis)
141: throws ResourcePoolException;
142:
143: public abstract long getExcessResourceMaxIdleTime()
144: throws ResourcePoolException;
145:
146: public abstract long getDestroyOverdueResourceTime()
147: throws ResourcePoolException;
148:
149: public abstract void setDestroyOverdueResourceTime(long millis)
150: throws ResourcePoolException;
151:
152: public abstract void setExpirationEnforcementDelay(long millis)
153: throws ResourcePoolException;
154:
155: public abstract long getExpirationEnforcementDelay()
156: throws ResourcePoolException;
157:
158: public abstract void setBreakOnAcquisitionFailure(boolean b)
159: throws ResourcePoolException;
160:
161: public abstract boolean getBreakOnAcquisitionFailure()
162: throws ResourcePoolException;
163:
164: public abstract void setDebugStoreCheckoutStackTrace(
165: boolean debug_store_checkout_stacktrace)
166: throws ResourcePoolException;
167:
168: public abstract boolean getDebugStoreCheckoutStackTrace()
169: throws ResourcePoolException;
170:
171: // /**
172: // * Sets whether or not maxAge should be interpreted
173: // * as the maximum age since the resource was first acquired
174: // * (age_is_absolute == true) or since the resource was last
175: // * checked in (age_is_absolute == false).
176: // */
177: // public abstract void setAgeIsAbsolute( boolean age_is_absolute )
178: // throws ResourcePoolException;
179:
180: // public abstract boolean getAgeIsAbsolute()
181: // throws ResourcePoolException;
182:
183: public abstract ResourcePool createPool(ResourcePool.Manager mgr)
184: throws ResourcePoolException;
185: }
|