Is there a time frame for when JDBC driver will comply with the
specification with regard to being thread safe. The spec is clear that
"For example, two Statement
objects on the same connection can be executed concurrently, and their
ResultSets can be processed concurrently (from the perspective of the
developer)."
The driver as is does support this capability.
Martin Smith
http://java.sun.com/products/jdbc/driverdevs.html
A.1.6 Support Multithreading
All operations on java.sql
and javax.sql objects are required to be multithread safe. They must be
able to cope correctly with having several threads simultaneously calling
the same object. In other words, a statement execution in one thread
should not block an execution in another thread. In particular, JDBC
drivers should operate correctly when used from multiple threads.
An example of a specific use of multithreading is the way a
long-running statement can be cancelled. This is done by using one thread
to execute the statement and a second one to cancel it with the method
Statement.cancel.
Even though it is expected that in practice most JDBC objects will
be accessed in a single-threaded way, there needs to be support for
multithreading.
Some database APIs, such as ODBC, provide mechanisms for allowing SQL
statements to execute asynchronously. This allows an application to start
up a database operation in the background and then handle other work
(such as managing a user interface) while waiting for the operation to
complete.
Since Java is a multithreaded environment, there seems to be no real need
to provide support for asynchronous statement execution. Java programmers
can easily create a separate thread if they wish to execute statements
asynchronously with respect to their main thread.
Some drivers may allow more concurrent execution than others, but
developers should be able to assume fully concurrent execution. If the
driver requires some form of synchronization, then the driver should
provide it. In this situation, the only difference visible to the
developer should be that applications run with reduced concurrency.
For example, two Statement objects on
the same connection can be executed concurrently, and their ResultSets
can be processed concurrently (from the perspective of the developer).
Some drivers will provide this full concurrency. Others may execute one
statement and wait until it completes before sending the next one.
