Instance variables

[Jeppe Sommer]

Regarding the multi thread issue in the previous discussion I understand that we shouldn't declare istance variables in the servlet.

But what about declaring instance variables in another class, which is called from the servlet? Please see the example below.

If two theads are requesting MyServlet at the same time, are there any risk that thread 2 could overwrite the public instance variables initiated in the class called SessionHandler, when called from the servlet as below?

Please note that a local instance of SessionHandler is created in the servlets doGet method.

Do you see any problems in the code below in an application with many requests?

import SessionHandler;

public class MyServlet extends HttpServlet {

   public void doGet ( HttpServletRequest request, HttpServletResponse response ) throws ServletException, IOException {         
                       
         try {         
  
                  javax.servlet.http.HttpSession session = null;
                  java.util.Hashtable id = null;

                  java.sql.Connection conn = null;             
              
                  int companyID = 0;      
                  int custID = 0;         
                   
                  SessionHandler obj_sessionHandler = new SessionHandler();
                  int sessResponseCode = obj_sessionHandler.getSessionResponse();                   
                               
                  //Only access if user session is valid, otherwise you get redirected to login page          
                  if ( sessResponseCode > 0  ){         
     
                         conn = obj_sessionHandler.conn; 
                         id= obj_sessionHandler.id; 
                         session = obj_sessionHandler.session;     
                         custID = obj_sessionHandler.custID;            
                         companyID = obj_sessionHandler.companyID;      
                  }   
                      
                  ....   
}
...  

public class SessionHandler {
     
     public sessResponseCode = 0;
     public javax.servlet.http.HttpSession session;
     public java.util.Hashtable id;
     public dbConn.DBConn db;
     public java.sql.Connection conn;
     public int companyID = 0;
     
     public int getSessionResponse() throws Exception {
              
              session = null;
              companyID = 0;
              
              conn = null;
              db = null;
              
              session = request.getSession( false );
              
              if ( session != null && session.getAttribute("ids") != null ){
                   
                   id = ( java.util.Hashtable ) session.getAttribute("ids");
                  
                   if ( id.get("companyID") != null )
                   companyID = Integer.parseInt( ( String ) id.get("companyID") );
              
                   if ( companyID > 0 ){
                      sessResponseCode = 1;
                   }
                   else {
                      sessResponseCode = 0;
                   }
              }
              else {
                       
                    sessResponseCode = 0;
              }

              return  sessResponseCode;
     }
}

[Matthew Brown]

That looks fine (the principle - I haven't looked at the detail), because the instance of SessionHandler you're creating is local to the doGet method. As long as everything is local to the method then you're safe from threads interacting.

[Tim Holloway]

As long as the SessionHandler is an object created and destroyed within the scope of the doGet() method, there's no problem with SessionHandler and threads, because each thread has its own stack and a unique instance of SessionHandler will reside there. Since the difference between class members and instance members is that instance members are unique to each instance instead of being shared between instances like class members are, there's no conflict.

[Jeppe Sommer]

Tim Holloway wrote:As long as the SessionHandler is an object created and destroyed within the scope of the doGet() method, there's no problem with SessionHandler and threads, because each thread has its own stack and a unique instance of SessionHandler will reside there. Since the difference between class members and instance members is that instance members are unique to each instance instead of being shared between instances like class members are, there's no conflict.

So, do we also need to destroy the SessionHandler object manually, something like? If so, why is that?

public void doPost ( HttpServletRequest request, HttpServletResponse response ) throws ServletException, IOException {
      
      SessionHandler obj_sessionHandler = null;
      
       try {
              
                 sessionHandler  = new SessionHandler();   
                 ....
      }
      finally {
                 
                 sessionHandler = null;
      }
}