That is the important bit, it doesn't matter a jot about it being a
singleton.

Every caller gets there own copy of local variables in a method.

Thread safety means no corruption of data, ie one thread doesn't change
something another thread may read, unless it is intended in a controlled
manner that the programmer has coded for through proper synchronisation.

So if there are no class level variables (we call these attributes or
instance variables) then what is there to corrupt?

--
Mike W

I am not quite sure what you mean by "singleton method". A method is
reentrant (which is a bit stronger then most definitions thread safe)
if it does not modify any state, that is, if it is free of
side-effects. If your method can claim that, then yes, it is
thread-safe even without explicit synchronization.

   I'm not familiar with your terminology of "method level variables" and
"class level variables". There's 3 types of variables to be concerned with
here: static fields, instance field, and local variables.

   If you've got static fields, then you might have threading problems.

   If you've got instance fields, then you might have threading problems.

   If you only have local variables, then you should be okay.

   - Oliver

Make sure you make the instance variable itself final. Using lazy
initialization at the first getInstance() request might seem like
a good idea, but is not thread-safe. Use this pattern:

  private MySingleton
  {
    private static final MySingleton instance_ = new MySingleton();

    public static MySingleton getInstance()
    {
      return instance_;
    }

    private MySingleton()
    {
    }
  }

The other methods must be synchronized according to their class
scope variable usage, and since you don't have any, there are no
further issues.