单例模式如果细分的话至少有8种以上（笔者知道的实现方式大概就有10种左右）的实现方式，这其中有一些实现方式是存在问题的，例如：线程安全问题、原子性问题等。笔者将列举出可行的单例模式的实现方式（存在问题的方式将不在此列举），并分析其中的优缺点。
    以下是笔者的代码，其中饿汉式和懒汉式是以往最经典和常用的方式：
    饿汉式（静态常量）：

/**
 * 饿汉式（静态常量）
 * 优点：这种写法比较简单，在类装载的时候就完成实例化。避免了线程同步问题。
 * 缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用           过这个实例，则会造成内存的浪费。
 * 
 * @author JsonLiangyoujun
 * **/
public class HungryMan {
	/*初始化实例*/
	private static final HungryMan hungryMan = new HungryMan();
	
    /*对外提供获得实例调用方法*/
    public static HungryMan getHungryMan() {
		return hungryMan;
	}
    
    /*必须私有化构造方法才能达到单例效果*/
    private HungryMan(){};
     
}

    该方式不能实现懒加载、参数化、配置化，简单地说就是不够灵活。但却是一种简单可行的方式，在Java jdk中就有用到该方式实现单例，例如Runtime类。虽然jdk中没有使用final，但达到的效果是相同的，该方式还能用静态代码块实现。代码如下：
    饿汉式（静态代码块）：

 /** 
 * 饿汉式（静态代码块）
 * @author JsonLiangyoujun
 * **/
public class HungryMan {
	
	private static HungryMan hungryMan;
	
	static{
		hungryMan = new HungryMan();
	}
	
	public static HungryMan getHungryMan() {
		return hungryMan;
	}
    
	private HungryMan(){};
     
}

    该方式效果和优缺点同上。

    懒汉式（线程同步）：

/**
 * 懒汉式（线程同步）
 * 优点：这种写法比较简单，达到了Lazy Loading的效果。解决了线程同步问题。
 * 缺点：效率太低了，每个线程在想获得类的实例的时候，执行getLazyMan()方法都要进行同步。
 * 而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。
 * 
 * @author JsonLiangyoujun
 * **/
public class LazyMan {

	private static LazyMan lazyMan;
	
	private LazyMan(){};
	
    public static synchronized LazyMan getLazyMan() {
    	if(lazyMan == null){
    		lazyMan = new LazyMan();
    	}
		return lazyMan;
	} 
}

    该方式达到了实现懒加载、可参数化、可配置化的要求，但是明显的缺点就是效率太低。

    懒汉式（双重检查）：

/**
 * 懒汉式（双重检查）
 * 优点：线程安全；延迟加载；效率较高。
 * 
 * @author JsonLiangyoujun
 * **/
public class LazyManDoubleCheck {

	private static volatile LazyManDoubleCheck lazyMan;
	
	private LazyManDoubleCheck(){};
	
    public static LazyManDoubleCheck getLazyMan() {
    	if(lazyMan == null){
    		lazyMan = new LazyManDoubleCheck();
    		synchronized (LazyManDoubleCheck.class) {
                if (lazyMan == null) {
                	lazyMan = new LazyManDoubleCheck();
                }
            }
    	}
		return lazyMan;
	} 
}

    该方式值得推荐使用，使用该方式需要对线程知识有一定的了解。

    除了饿汉式和懒汉式，下面笔者再提供两种值得推荐的方式。
    静态内部类式：
   

/**
 * 静态内部类式
 * 优点：避免了线程同步问题，延迟加载，效率高。。
 * 
 * @author JsonLiangyoujun
 * **/
public class StaticInnerClass {
	private StaticInnerClass(){}
	
	private static class StaticInnerClassInstance{
		private static final StaticInnerClass staticInnerClass = new StaticInnerClass();
	}
	
	public static  StaticInnerClass getStaticInnerClass(){
		return StaticInnerClassInstance.staticInnerClass;
	}
}

    该方式类似于饿汉式和懒汉式的结合版，既避免了线程同步问题，又支持延迟加载，还提高了效率。

    枚举式
   

/**
 * 枚举式
 * 优点：避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
 * 
 * @author JsonLiangyoujun
 * **/
public enum Singleton {
	 INSTANCE;
	 public void whateverMethod() {}
}

    该方式简单直接。不过目前使用的频率不高，可能是因为枚举是在JDK1.5之后的新特性的原因，大家还未习惯使用枚举吧。
   
    以上六种方式均为可行的实现单例模式的方式，可根据具体需求进行选择。
    原文永久地址： http://jsonliangyoujun.iteye.com/blog/2355384