Why pool Stateless session beans?

Question

Stateless beans in Java do not keep their state between two calls from the client. So in a nutshell we might consider them as objects with business methods. Each method takes parameters and return results. When the method is invoked some local variables are being created in execution stack. When the method returns the locals are removed from the stack and if some temporary objects were allocated they are garbage collected anyway.

From my perspective that doesn’t differ from calling method of the same single instance by separate threads. So why cannot a container use one instance of a bean instead of pooling a number of them?

Answer 1

Pooling does several things.

One, by having one bean per instance, you're guaranteed to be threads safe (Servlets, for example, are not thread safe).

Two, you reduce any potential startup time that a bean might have. While Session Beans are "stateless", they only need to be stateless with regards to the client. For example, in EJB, you can inject several server resources in to a Session Bean. That state is private to the bean, but there's no reason you can't keep it from invocation to invocation. So, by pooling beans you reduce these lookups to only happening when the bean is created.

Three, you can use bean pool as a means to throttle traffic. If you only have 10 Beans in a pool, you're only going to get at most 10 requests working simultaneously, the rest will be queued up.

Answer 2

Here’s my own idea why several objects are needed. We need to isolate an execution context of each parallel invocation. But it’s not possible to initialize this context on a method frame level because there’s no means to manipulate frames at runtime in JVM. The metaprogramming capabilities of the runtime are very limited in Java. That’s why it’s required to set up execution context on object level instead. Hence, each parallel call needs its own instance of the bean and pooling is a natural optimization technique.

Answer 3

Life cycle of the Statelesss session beans are Doesnot exist, Passive and MethodReady(Passive or Inactive) state.To optimize on perormance, instead of traversing the bean all through from create to method ready state, container manages the bean between active and passive states through the container callbacks - ejbActivate() and ejbPassivate() there by managing the bean pool.

sreenut

Answer 4

Pooling enhances performance.

A single instance handling all requests/threads would lead to a lot of contention and blocking.

Since you don't know which instance will be used (and several threads could use a single instance concurrently), the beans must be threadsafe.

The container can manage pool size based on actual activity.

Answer 5

The transactionality of the JEE model uses the thread context to manage the transaction lifecycle.

This simplification exists so that it is not necessary to implement any specific interface to interact with the UserTransaction object directly; when the transaction is retrieved from the InitialContext (or injected into the session bean) it is bound to a thread-local variable for reuse (for example if a method in your stateless session bean calls another stateless session bean that also uses an injected transaction.)