是否可以在单个JDBC连接上多路复用多个只读事务

Question

Firstly, I have given few data points.
Next will be the problem described.

---

DATA POINTS:
[D1] In Hibernate and Annotation and managed objects world, what i have seen a common pattern like

@Transactional
public void createStuff(..){
// get entity manager and call persist and other operatation
}
@Transactional
public SomeDtoObject getStuff(..){
// get entity manager and call find and getter to polulate a object to return
}

In managed beans the Hibernate transaction is started and commited when we call this methods.

Hibernate doc says ( link ):

The most common pattern in a multi-user client/server application is session-per-request.

[D2] Also it is advised that connection to database should be pooled using connection pool library C3P0 as stated on postgres documentation ( link ):

Pg will usually complete the same 10,000 transactions faster by doing them 5, 10 or 20 at a time than by doing them 500 at a time.

[D3] Also with JDBC
Given a single connection we can run one transaction at a time and as many statement as we like within that transaction.
Its upto the application(C3P0) to make sure that two different thread executing two different transactional method should not use same connection and one should wait before calling the other method .

---

Problem:
Now if we use the managed bean transaction pattern using annotation along with a connection pool( Let say only with 1 connection ) with hibernate and session-per-request
Also let say the code is something like

@Transactional
public SomeDtoObject getStuff(..){
// get entity manager and call find and getter to polulate a object to return
SomeEntity se = entityManager.find(someentity, primaryKey);
//create Dtos
// access someEntity to all over this method to create SomeDtoObject that we have to return.
// also may access some file on system to fetch some data is order to populate someDtoObject.
// overall let say the method take 150 milli second to do all its work
}

Now imagine there are two different thread( T1 , T2 ) called for getStuff(...) T1 will enter the method and will acquire jdbc connection from connection pool.
And when T2 will reach entityManager.find the C3P0 will check that there is no connection left it will put T2 on hold till T1 complete the execution which will take around 150 milli second.

Ideally, Given that getStuff(...) is going to do read only querys, both thread can use same connection and dont hold thread from executing queries.
In above case we are keep that connection idle and also keeping the thread to wait.

MAIN QUESTION
Is there a way i can say to hibernate that a particular hibernate transaction is readonly and hibernate can then reuse an already acquired connection instead of asking for a new connection from the connection pool ?

---

Few solution found/suggested:(not convincing)

1 If you are so much worried, dont use transaction using annotation, use hibernate session yourself..... no i like that pattern :)
2 Hibernate provide a ConnectionRelease link option which can be set to after_statement .
First Hibernate C3P0 connection pool provider does not support after_statement.
Second it will be a overhead just release and reacquire a connection.

Answer 1

You cannot multiplex transactions coming from different threads to a one JDBC connection. Even if the JTA spec says that this might be possible, in reality, this doesn't happen, and the JDBC drivers are synchronous.

Neither 1) and 2) and the right suggestions for your needs.

1. You should be using the underlying platform transactional support (eg Java EE, Spring), instead of managing transaction boundaries yourself.
2. The after_statement incurs some penalty , while it still binds the transaction to a connection.

So, the viable alternatives are:

1. Reduce transaction time as much as possible so that you can execute a lot of transactions per database connection.
2. Increase available read-only connections by using master-slave database replication and route read-only transactions to slaves.