CODEWITHSUNDEEP
java
Anthos
Anthos

Reputation: 41

static method and thread safety

Is the following code threadsafe ?

    public static Entity getInstance(){
//the constructor below is a default one.
     return new Entity();
    }

Upvotes: 4

Views: 1620

Answers (5)

Jon Skeet
Jon Skeet

Reputation: 1503090

Assuming the constructor itself is thread-safe, that's fine.

It would be very unusual for a constructor not to be thread-safe, but possible... even if it's calling the default auto-generated constructor for Entity, the base constructor may not be thread-safe. I'm not saying it's likely, just possible :)

Basically there's no magic thread-safety applied to static methods or instance methods or constructors. They can all be called on multiple threads concurrently unless synchronization is applied. If they don't fetch or change any shared data, they will generally be safe - if they do access shared data, you need to be more careful. (If the shared data is immutable or only read, that's generally okay - but if one of the threads will be mutating it, you need to be really careful.)

Only static initializers (initialization expressions for static variables and static { ... } blocks directly within a class) have special treatment - the VM makes sure they're executed once and only once, blocking other threads which are waiting for the type to be initialized.

Upvotes: 6

Sean Patrick Floyd
Sean Patrick Floyd

Reputation: 299148

It's probably thread safe, but what's the point? If you're just using a factory method to redirect to the default constructor then why not use the constructor in the first place? So the question is: what are you trying to achieve? The name getInstance() suggests a singleton (at least that's common practice), but you clearly don't have a singleton there. If you do want a singleton, use a static inner holder class like this:

    public class Singleton {

        private Singleton() {
        }

        public static Singleton getInstance() {
            return InstanceHolder.INSTANCE;
        }

        private static final class InstanceHolder {

            public static final Singleton INSTANCE = new Singleton();

        }
    }

but if you don't, why bother with such a factory method, as you're not adding any value (method name semantics, object pooling, synchronization etc) through it

Upvotes: 2

Jesper
Jesper

Reputation: 206946

Thread safety is about access to shared data between different threads. The code in your example doesn't access shared data by itself, but whether it's thread-safe depends on whether the constructor accesses data that could be shared between different threads.

There are a lot of subtle and hard issues to deal with with regard to concurrent programming. If you want to learn about thread safety and concurrent programming in Java, then I highly recommend the book Java Concurrency in Practice by Brian Goetz.

Upvotes: 1

Arne Deutsch
Arne Deutsch

Reputation: 14779

Multiple threads could call this method and each one will get an unique instance of 'Entity'. So this method 'per se' is thread safe. But if there is code in the constructor or in one of the super constructors that is not thread safe you might have a safety problem anyhow.

Upvotes: 0

R Samuel Klatchko
R Samuel Klatchko

Reputation: 76601

It depends on the details of the Entity constructor. If the Entity constructor modifies shared data, then it is not.

Upvotes: 4

Related Questions