Singletons and Static class behavior

Question

Hi all and thanks for taking a look at this,
I was playing around with a Singleton class today and it raised raised a few questions around Static methods in the singleton. When my class is instatiated I load some data into a HashMap map that I want to make available for read only purposes through other methods in my singleton.
I really wanted to just call a static method to look up the value, so I followed the standard model. I had a private static HashMap that is loaded with data when the Contructor is called from the getInstance(). I included the standard model example for you if you wanted to refer to it.
I ran my code making a static MyClass.getData() call to see what would happen. The static call did not return a value, I wasn't surprised. Then I added a call to MyClass.getInstance() followed by the static MyClass.getData() call and this returned the appropriate value.
Then I changed my Singleton as follows and was wondering if there were any issues that might result because of this and I was wondering what the process that is followed by java when calling a static method (what does it use, where does it look).
My Code:
public class MyClass {
private static MyClass instance;
private static HashMap myData;
private MyClass() {
myData = new HashMap();
myData.put("1", "value 1");
myData.put("2", "value 2");
private static synchronized void getInstance() {
if (instance == null)
instance = new MyClass();
public static String getData(String key) {
if (myData == null)
getInstance();
return (String)myData.get(key);
The standard singleton model class:
public class MyClass {
private static MyClass instance;
private MyClass() { }
public static synchronized MyClass getInstance() {
if (instance == null)
instance = new MyClass();
return instance;
... rest of methods (not static)
}

Answer 1

Thanks for the reply,
Really my only reason for making it static was so the calling class would not have to get a handle to the actual MyClass Instance. Therefore avoiding the Synchronization method.
I was attempting to aviod the famous broken double check locking by having the checks in different methods. I am assuming from you warning that keeping the methods seperate and synchronizing the getInstance is really no different than putting a synchronize(this) block around the second check and the constructor call?
Really my objective is to retrive data once, not really create a single access point for getting the data. As an alternative, I tried the following code and it seems to work, any issues you can see with this?
public class MyClass {
private static HashMap hm;
static {
hm = new HashMap();
// code to get Data into HashMap
public static String getData(String key) {
return hm.get(key);