SFSB and BMT JTA Transaction Scope confusion

Question

Hi,
I'm a bit confused with the scope of a UserTransaction.
* Classic SFSB with BMT
@Stateful
@TransactionManagement(TransactionManagementType.BEAN)
public class SFSBean implements SFS {
     private @Resource UserTransaction tx;
     private @PersistenceUnit(unitName="my-db") EntityManagerFactory emf;
     private EntityManager em;
     public void start() {
          try {
               tx.begin();
          } catch (NotSupportedException e) {
               throw new RuntimeException(e);
          } catch (SystemException e) {
               throw new RuntimeException(e);
          em = emf.createEntityManager();
     public void doJob1() {
     public void doJob2() {
     @Remove
     public void commit() {
          try {
               tx.commit();
          } catch (SecurityException e) {
               throw new RuntimeException(e);
          } catch (IllegalStateException e) {
               throw new RuntimeException(e);
          } catch (RollbackException e) {
               throw new RuntimeException(e);
          } catch (HeuristicMixedException e) {
               throw new RuntimeException(e);
          } catch (HeuristicRollbackException e) {
               throw new RuntimeException(e);
          } catch (SystemException e) {
               throw new RuntimeException(e);
     @Remove
     public void rollback() {
          try {
               tx.rollback();
          } catch (IllegalStateException e) {
               e.printStackTrace();
          } catch (SecurityException e) {
               e.printStackTrace();
          } catch (SystemException e) {
               e.printStackTrace();
}When I request this SB the container inject a JTA transaction inside my variable tx and this transaction will be bound to the life of my SB.
But : if a handler for this SB is associated to a SessionScoped or ConversationScoped bean (CDI contexts) or simply to a HttpSession attribute, then calls to SB methods may occurs in different thread (successives requests).
Is this pattern supported? As JTA rely on ThreadLocal but a transaction can also be injected inside a SFSB: I'm a bit confused...
HttpRequest1[Thread-1] : ejbHandler.start(); // conversation start
HttpRequest2[Thread-2] : ejbHandler.doJob1(); // long running transaction
HttpRequest3[Thread-1] : ejbHandler.doJob2(); // long running transaction
HttpRequest4[Thread-3] : ejbHandler.commit(); // conversation end
I tried a small use case and it seems to work (maybe all my requests was part of the same thread, lucky me) with JBoss but if an error occurs the transaction manager seems completely confused.
If this pattern is legal (I know it is a very bad pattern...), I'll try to fix my code, if it isn't I'll have to drop JTA from this part of the code...
Thank you.

Answer 1

Yes, this is part of the required transactional behavior for a stateful session bean. A stateful session bean is the only session bean type whose bean instances can retain their association with a transaction after the business method returns. It's then the container's job to set up the correct transaction context for each successive invocation of the stateful session bean instance, until the transaction is committed or rolled back. If a system exception is thrown from the stateful session bean method the instance will be destroyed.