1.饿汉式,优点是实现比较简单，不存在多线程同步问题，避免synchronized所造成的性能问题,缺点是当类被加载的时候，会初始化静态的实例，静态实例被创建并分配内存空间，实例会一直占用这段内存,即使没有用到这个实例，当类被卸载时，静态实例被摧毁，并释放所占用的内存，因此在某些特定条件下会耗费内存

package com.mycompany.singletondemo;

/**
 * 线程安全 ,饿汉式
 * @author Administrator
 *
 */
public class Singleton1 {
	
	//构造方法私有化
	private Singleton1(){}
	
	//定义static和final类型的实例对象
	private static final Singleton1 instance = new Singleton1();
	
	/*
	 * 通过静态方法获取实例
	 */
	public static Singleton1 getInstance(){
		return instance;
	}
}

2.饱汉式,优点实现比较简单，当类被加载时，静态实例未被创建且未分配内存空间，当getInstance方法第一次被调用时，初始化实例并分配内存，因此在某些特定条件下会节约内存,缺点是并发环境下很可能出现多个实例

package com.mycompany.singletondemo;

/**
 * 线程非安全,饱汉式
 * @author Administrator
 *
 */
public class Singleton2 {
	
	//构造方法私有化
	private Singleton2(){}
	
	//定义变量
	private static Singleton2 instance;
	
	//定义静态方法获取实例
	public static Singleton2 getInstance(){
		if (instance == null) {
			instance = new Singleton2();
		}
		
		return instance;
	}
}

3.饱汉式,优点是使用synchronized关键字避免多线程访问时，出现多个实例,缺点同步方法频繁调用时，效率低

package com.mycompany.singletondemo;

/**
 * 线程安全,同步方法频繁调用时,效率低,多线程访问不会出现多个实例
 * @author Administrator
 *
 */
public class Singleton3 {
	private Singleton3(){}
	
	private static Singleton3 instance;
	
	public static synchronized Singleton3 getInstance(){
		if(instance == null){
			instance = new Singleton3();
		}
		
		return instance;
	}
}

4.线程安全,效率高,最优方案

package com.mycompany.singletondemo;

/**
 * 线程安全,效率高,内存占用少
 * @author Administrator
 *
 */
public class Singleton4 {
	private Singleton4(){}
	
	private static volatile Singleton4 instance;
	
	public static Singleton4 getInstance(){
		if (instance == null) {
			synchronized (Singleton4.class) {
				if (instance == null) {
					instance = new Singleton4();
				}
			}
		}
		
		return instance;
	}
}

本文出自 “素颜” 博客，谢绝转载！

设计模式-单例模式