Using SingleThreadModel

Question

Hello
I'm reading about ways to make my servlets thread safe. As I have learned , there are two main ways,
using synchronized block around some code or using SingleThreadModel. (Please correct me if wrong).
My servlets work in an environemnt where data of database is frequently updated, therefore in their doPost() or doGet() method they stablish a connection to database, get the required data, close the connection and use an arraylist to display the result. (Again please feel free to add your comments on how to best go about this)
Inside servelts, I do not call any classes (all code of access db is directly inside servelt) and just use some local variables for loops and temp storage and such.
I appreciate your help with two points:
1. I would like to use SingleThreadModel for a servlet that updates the database; I have read in
http://www.exampledepot.com/egs/javax.servlet/NoMulti.html?l=rel
that this is not sufficeint to properly synchronize shared state and developer should do it. Could you please explain what is meant by shared state and how I can do that ?
2. For servlets that just run queries, I think I should use synchronized block around some code, but I am not sure which parts of code should be contained in it ?
Moreover , it is advised not to synchronize doPost or doGet methods ...
Could you please help me understand what is the best strategy to choose to make sure performance is good and all operations are thread safe?
Thank you very much in advance
Nicole

Answer 1

Use of the SingleThreadModel is discouraged for various reasons. I would not recommend that path.
Probably need more information about what is needed to be synchronized.
For query only, I would imagine that no synchronization is necessary.
With regards to thread safety/synchronization/consistency of data there are a few levels to consider.
1 - Servlet level.
The standard model is that a servlet is instantiated once, and then runs multiple threads through its "service" method.
The easiest way to have a threadsafe servlet is to use local variables only. Class attributes in the servlet would be shared by all threads accessing that class, and thus would not be threadsafe.
public class MyServlet extends HttpServlet{
  private String nonThreadSafeVariable = "hello";
  protected void doPost(HttpServletRequest req, HttpServletResponse resp)throws ServletException, java.io.IOException{
    String threadSafeVariable = "world";
}So if each call to your servlet obtains its own database connection (preferably from a connection pool) runs its queries and closes/returns it, you will not have concurrency issues there.
In this simple model you don't need to worry about synchronizing things.
2 - Making it more complicated. Data/Transaction level.
If you need to ensure read/write consistency - ie read a value from the database, and then write back an updated value without someone getting that same "before" value (updating someones bank account is the classic example) then you need to synchronize around the whole operation.
So that you lock, read, write unlock. That is probably best done with a database transaction / lock. If doing it in java, then I would implement this in a bean layer outside of the servlets, and have the servlets call that layer.
Hope this helps some,
evnafets