Synchronizing Session Counter

[A Phatak]

I keep having some trouble understanding synchronizing concept in the context of static vs nonstatic. For e.g. take a look at the code below:

package com.listeners;
import javax.servlet.*;
import javax.servlet.http.*;

public class AppSessionListener implements HttpSessionListener {
	private static int _counter=0;
	
	public void sessionCreated(HttpSessionEvent event) {

		_counter++;
	}
	
	public void sessionDestroyed(HttpSessionEvent event){
		if (_counter > 0) {
			_counter--;
		}
	}
	
	public static int getSessionCounter(){
		return _counter;
	}
}

It is a simple listener that counts number of active sessions. However, we know HttpSession object is not thread safe. So I believe that "counter" variable should be incremented in a "synchronized" manner.

It is clear that getCounter() should change to public synchronized static int getSessionCounter()

My question is what changes should be implemented in sessionDestroyed() and sessionCreated() methods? Which of the following is correct?

// DOUBT: the containing method is instance method and _counter is static
// Can I synchronize on "class" inside instance method?
synchronized(AppSessionListener.class) {
	_counter++;
}

OR

// DOUBT: _counter is static and but we are simply synchronizing the Instance of AppSessionListener object
// Doesn't feel right??
synchronized(this) {
	_counter++;
}

Or does it have to be synchronized at all?

[A Phatak]

Sorry if this is a wrong place for this question? I am studying for the OCEWCD and thought this is my forum. If not please redirect me appropriately

[Frits Walraven]

Hi Phatak

Sorry if this is a wrong place for this question? I am studying for the OCEWCD and thought this is my forum. If not please redirect me appropriately

It is perfectly ok to ask a question regarding threads over here although this topic belongs to the basic concepts of OCPJP you still need to know about it in OCEWCD.

Every object (or instance) has one lock and every class has exactly one lock. Locking on static methods (accessing static data) is usually done on the class, where locking instance methods is mostly done on the instance (this()).

As there is only one listener object per listener declaration in the web-container (the container will instantiate your listener) you can also give the listener a private instance variable holding a counter. So counting the sessions in the listener class instance variable will have the same effect as counting the sessions in a static variable.

So these two implementations will both work:

Locking on the class

package listener;

import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class AppSessionListenerStatic implements HttpSessionListener {

	private static int _counter=0;
	
	@Override
	public void sessionCreated(HttpSessionEvent arg0) {
    	increaseCounter();
	}

	@Override
	public void sessionDestroyed(HttpSessionEvent arg0) {
      decreaseCounter();    
	}

    public static synchronized int getSessionCounter(){  
        return _counter;  
    }
    private static synchronized void increaseCounter(){
    	 _counter++;
    	 System.out.println("SessionStaticCounter created: " + getSessionCounter());
    }
    private static synchronized void decreaseCounter(){
   	 if (_counter>0) {
   		_counter--;
   		System.out.println("SessionStaticCounter removed: " + getSessionCounter());
   	 }
   }
}

Locking on this()

package listener;

import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
  
public class AppSessionListener implements HttpSessionListener {  
	
    private int _counter=0;
    
    public void sessionCreated(HttpSessionEvent event) {
    	increaseCounter();
    }  
      
    public void sessionDestroyed(HttpSessionEvent event){
    	decreaseCounter();
    }  
      
    public synchronized int getSessionCounter(){  
        return _counter;  
    }
    private synchronized void increaseCounter(){
    	 _counter++;
    	 System.out.println("SessionNonStaticCounter created: " + getSessionCounter());
    }
    private synchronized void decreaseCounter(){
   	 if (_counter>0){
   		_counter--;
   		System.out.println("SessionNonStaticCounter removed: " + getSessionCounter());
   	 } 		 
   }
}   

Regards,
Frits