Connection pooling
Use connection pools helps to both alleviate connection management overhead and decrease development tasks for data access.
Each time an application attempts to access a backend store (such as a database), it requires resources to create, maintain, and release a connection to that datastore. To mitigate the strain this process can place on overall application resources, WAS enables administrators to establish a pool of backend connections that applications can share on an appserver.
Connection pooling spreads the connection overhead across several user requests, thereby conserving application resources for future requests.
WAS supports JDBC 3.0 APIs for connection pooling and connection reuse. The connection pool is used to direct JDBC calls within the application, as well as for enterprise beans using the database.
Benefits of connection pooling
Connection pooling can improve the response time of any application that requires connections, especially Web-based applications. When a user makes a request over the Web to a resource, the resource accesses a data source. Because users connect and disconnect frequently with applications on the Internet, the application requests for data access can surge to considerable volume. Consequently, the total datastore overhead quickly becomes high for Web-based applications, and performance deteriorates. When connection pooling capabilities are used, however, Web applications can realize performance improvements of up to 20 times the normal results.
With connection pooling, most user requests do not incur the overhead of creating a new connection because the data source can locate and use an existing connection from the pool of connections. When the request is satisfied and the response is returned to the user, the resource returns the connection to the connection pool for reuse. The overhead of a disconnection is avoided. Each user request incurs a fraction of the cost for connecting or disconnecting. After the initial resources are used to produce the connections in the pool, additional overhead is insignificant because the existing connections are reused.
When to use connection pooling
Use WebSphere connection pooling in an application that...
- Cannot tolerate the overhead of obtaining and releasing connections whenever a connection is used.
- Requires Java Transaction API (JTA) transactions within WAS.
- Needs to share connections among multiple users within the same transaction.
- Needs to take advantage of product features for managing local transactions within the appserver.
- Does not manage the pooling of its own connections.
- Does not manage the specifics of creating a connection, such as the database name, user name, or password
How connections are pooled together
When you configure a unique data source or connection factory, give it a unique JNDI name. This JNDI name, along with its configuration information, is used to create the connection pool. A separate connection pool exists for each configured data source or connection factory. Furthermore, Application Server creates a separate instance of the connection pool in each appserver that uses the data source or connection factory. For example:
- If you run a three server cluster in which all of the servers use myDataSource, and myDataSource has a Maximum Connections setting of 10, then you can generate up to 30 connections (three servers times 10 connections).
Consider how this behavior potentially impacts the number of connections that your backend resource can support. See Connection pool settings for more information. Other considerations for determining the maximum connections setting:
- Each entity bean transaction requires an additional database connection, dedicated to handling the transaction.
-
![[AIX]](../../aixlogo.gif)
![[HP-UX]](../../hpux.gif)
![[Solaris]](../../solaris.gif)
On supported UNIX systems, a separate DB2 process is created for each connection; these processes quickly affect performance on systems with low memory and cause errors.
- If clones are used, one data pool exists for each clone.
It is also important to note that when using connection sharing, it is only possible to share connections obtained from the same connection pool.
Avoiding a deadlock
Deadlock can occur if the application requires more than one concurrent connection per thread, and the database connection pool is not large enough for the number of threads. Suppose each of the application threads requires two concurrent database connections and the number of threads is equal to the maximum connection pool size. Deadlock can occur when both of the following are true:
- Each thread has its first database connection, and all are in use.
- Each thread is waiting for a second database connection, and none would become available since all threads are blocked.
To prevent the deadlock in this case, the maximum connections value for the database connection pool should be increased by at least one. Doing this allows for at least one of the waiting threads to obtain its second database connection and to avoid a deadlock. To avoid deadlock, code the application to use, at most, one connection per thread. If the application is coded to require C concurrent database connections per thread, the connection pool must support at least the following number of connections, where T is the maximum number of threads.
T * (C - 1) + 1
The connection pool settings are directly related to the number of connections that the database server is configured to support. If the maximum number of connections in the pool is raised, and the corresponding settings in the database are not raised, the application fails and SQL exception errors are displayed in the stderr.log file.
Sub-topics
Deferred Enlistment
Related concepts
Unshareable and shareable connectionsData sources
Transaction type and connection behavior
Related tasks
Change connection pool settings with the wsadmin toolConfigure connection factories for resource adapters within applications
Configure J2EE Connector connection factories in the console