When to synchronize JSP?

Question

Is there a simple rule for when I should use the synchronized keyword in JSP and Java? Should I always use it when many threads change an instance variable, for example when I declare variables with <%! %> and many users look at the page? In that case how come so many books forget about this, when they do for example a simple page counter (using an instance variable). Do I ever have to use synchronized if I only read from an instance variable without changing it? What is really an atomic statement? Is for example "i=i+1" an atomic statement? If not, when can it get interrupted an what happens with the parts? Could you also confirm that I never need to use the synchronized keyword for local variables?

Answer 1

Is there a simple rule for when I should use the
synchronized keyword in JSP and Java? Whenever you have an instance variable in a class that will be accessed by multiple threads, you should synchronize on methods that use that variable if it is possible for a method to return a false value due to that variable's state changing.
e.g.
private int x = 10;
private int y = 10;
public void method1()
  System.out.println("x = "+x);
  System.out.println("y = "+y);
  //AAA
  System.out.println("x + y = "+(x + y));
public void method2()
  x = x * 2;
}In the above code, if a thread enters method1 with x and y both equal to 10, and executes the whole method within its allocated time slice, then
x = 10
y = 10
x + y = 20
will be printed to the console.
But suppose the thread reaches the point marked AAA. If another thread takes over and executes method2, then when the first thread regains control, x will be 20, and the output would be
x = 10
y = 10
x + y = 30
This is obviously not the required behaviour, and can be stopped from happening by synchronizing the two methods.
Should I always
use it when many threads change an instance variable,
for example when I declare variables with <%! %> and
many users look at the page? Probably, yes. However, it does take at least 4 times as long to call a synchronized method as it does to call a non-synchronized one, so so if you can be sure that the above behaviour won't happen, don't synchronize.
If you are setting a variable in different places, but there are no methods that need to read the variable more than once, then you can probably get away without having to synchronize.
In that case how come so
many books forget about this, when they do for example
a simple page counter (using an instance variable). You tend not to read somehting like a page count more than once within a page, so it'll be correct at the point its used.
Synchronization is often not covered in JSP and servlet books because if you're reading them, you should probably already know Java and are expected to know about synchronization.
Do
I ever have to use synchronized if I only read from an
instance variable without changing it? No.
What is really
an atomic statement? Is for example "i=i+1" an atomic
statement? Yes. Every Java statement is executed as if it were an atomic statement (I remember reading that somewhere, but I'm not sure where).
If not, when can it get interrupted an what
happens with the parts? Could you also confirm that I
never need to use the synchronized keyword for local
variables?Confirmed. Each thread gets its own local variables.