Java Concurrency – Thread Safety?

Defining thread safety is surprisingly tricky. A quick Google search turns up numerous “definitions” like these:

  1. Thread-safe code is code that will work even if many Threads are executing it simultaneously.
  2. A piece of code is thread-safe if it only manipulates shared data structures in a manner that guarantees safe execution by multiple threads at the same time.

And there are more similar definitions.

Don’t you think that definitions like above actually does not communicate anything meaningful and even add some more confusion. Though these definitions can’t be ruled out just like that, because they are not wrong. But the fact is they do not provide any practical help or perspective. How do we make a difference between a thread-safe class and an unsafe one? What do we even mean by “safe”?

What is Correctness in thread safety?

At the heart of any reasonable definition of thread safety is the concept of correctness. So, before understanding the thread-safety we should understand first, this “correctness“.

Correctness means that a class conforms to its specification.

You will agree that a good class specification will have all information about a class’s state at any given time and it’s post condition if some operation is performed on it. Since we often don’t write adequate specifications for our classes, how can we possibly know they are correct? We can’t, but that doesn’t stop us from using them anyway once we’ve convinced ourselves that “the code works”. This “code confidence” is about as close as many of us get to correctness.

Having optimistically defined “correctness” as something that can be recognized, we can now define thread safety in a somewhat less circular way: a class is thread-safe when it continues to behave correctly when accessed from multiple threads.

A class is thread-safe if it behaves correctly when accessed from multiple threads, regardless of the scheduling or interleaving of the execution of those threads by the runtime environment, and with no additional synchronization or other coordination on the part of the calling code.

If the loose use of “correctness” here bothers you, you may prefer to think of a thread-safe class as one that is no more broken in a concurrent environment than in a single-threaded environment. Thread-safe classes encapsulate any needed synchronization so that clients need not provide their own.

Example: A Stateless Servlet

A good example of thread safe class is java servlets which have no fields and references, no fields from other classes etc. They are stateless.

public class StatelessFactorizer implements Servlet 
    public void service(ServletRequest req, ServletResponse resp) 
        BigInteger i = extractFromRequest(req);
        BigInteger[] factors = factor(i);
        encodeIntoResponse(resp, factors);

The transient state for a particular computation exists solely in local variables that are stored on the thread’s stack and are accessible only to the executing thread. One thread accessing a StatelessFactorizer cannot influence the result of another thread accessing the same StatelessFactorizer; because the two threads do not share state, it is as if they were accessing different instances. Since the actions of a thread accessing a stateless object cannot affect the correctness of operations in other threads, stateless objects are thread-safe.

That’s all for this small but important concept around What is Thread Safety?

Happy Learning !!

Was this post helpful?

Join 8000+ Awesome Developers, Like YOU!

7 thoughts on “Java Concurrency – Thread Safety?”

  1. Hi Lokesh,

    This is a excellent website. Thanks a lot.

    Please help me in one query that if My Class is running and I dont want any thread to interrupt it even from another JVM. Then whats should I do ?
    Will Class level lock works from another JVM also ?

  2. If a method parameters are primitive, each thread can maintain these values in its own stack, what about a method which has reference(s) to other objects as parameters, will each thread then also maintain the state of these objects in thread stack.. how this works.. pls explain,

    • State of objects will always be on heap not stack. If you have defined the objects with in the method then in this case each thread will have its own copy of objects, hence threadsafe.

      • Provided that the local objects are not exposed to the outside code. As objects are always created on the heap, they can be changed if a reference is available.


Leave a Comment

About HowToDoInJava

This blog provides tutorials and how-to guides on Java and related technologies.

It also shares the best practices, algorithms & solutions, and frequently asked interview questions.