Java常用GoF设计模式之一单例模式

单例模式概念及特点
　　java中单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例（应用比较少，不做介绍）三种。
　　单例模式有一下特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己自己创建自己的唯一实例。

　　3、单例类必须给所有其他对象提供这一实例。

单例的使用场景

懒汉式单例模式一（方法加锁）：

package cn.gof.singleton;
/**
 * @author zhaopan
 * @date 2016年10月21日 上午10:11:01
 * 单例模式--懒汉式
 * 优点：实现了简单的懒加载，真正用的时候才加载。
 * 缺点：方法同步，调用效率稍低
 */
public class Singleton03 {

	private static Singleton03 singleton03;
	private Singleton03(){
		
	}
	public static synchronized Singleton03 getInstance(){
		if (singleton03==null){
			singleton03=new Singleton03();
		}
		return singleton03;
	}
}

懒汉式单例模式二（双重检测锁机制）：

package cn.gof.singleton;
/**
 * @author zhaopan
 * @date 2016年10月21日 上午10:27:50
 * 双重检测锁机制的懒汉式
 * 优点：将同步内容下放到if内部，提高了执行效率，不必每次获取对象时进行同步。
 * 缺点：由于编译器优化和JVM底层内部模型原因，偶尔会出问题，不建议使用。JDK5.0以后版本若instance为volatile则可行
 * 
 * 因为这里的同步只需在第一次创建实例时才同步，一旦创建成功，以后获取实例时就不需要同获取锁了）
 * 但在Java中行不通，因为同步块外面的if (instance == null)可能看到已存在，但不完整的实例。
 * JDK5.0以后版本若instance为volatile则可行
 */
public class Singleton04 {

	//private static Singleton04 singleton04;
	private volatile static Singleton04 singleton04;
	private Singleton04(){
		
	}
	public static Singleton04 getInstance(){
		if(singleton04==null){
			synchronized (Singleton04.class) {
				if(singleton04==null){
					singleton04=new Singleton04();
				}
			}
		}
		return singleton04;
	}
}

为什么用volatile可以保证线程安全参考：

单例模式与双重检测

用happen-before规则重新审视DCL

懒汉式单例模式三（静态内部类的方式）：

package cn.gof.singleton;
/**
 * @author zhaopan
 * @date 2016年10月21日 上午10:46:40
 * 静态内部类方式  实现懒汉式单例
 * 优点：并发高效调用和延时加载的优势。
 * 外部类没有static属性，则不会像俄汉式那样立即加载对象。
 * 只有真正调用getInstance()，才会加载静态内部类。加载类时是线程安全的。
 * 因为instance是static final 类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证线程安全性。
 * 
 */
public class Singleton05 {

	private Singleton05(){
		
	}
	public static class SingletonInstance{
		private static final Singleton05 SINGLETON05 =new Singleton05();
	}
	
	public static Singleton05 getInstance(){
		return SingletonInstance.SINGLETON05;
	}
	
}

饿汉式单例模式一（静态常量实现）：

package cn.gof.singleton;
/**
 * @author zhaopan
 * @date 2016年10月21日 上午10:03:35
 * 最简单的单例模式 饿汉式
 * 		
 * 优点：static，此时不会设计多个线程对象访问该对象的问题。变量会在类加载时初始化线程安全，调用效率高
 * 缺点：无法实现延迟加载，如果是加载本类，而没有使用,则会造成资源浪费。
 */
public class Singleton01 {
	
	private static final Singleton01 singleton01=new Singleton01();
	//私有化构造方法
	private Singleton01() {
		
	}
	//提供公有的获取实例的方法
	public static Singleton01 getInstance(){
		return singleton01;
	}
	
	
	
}

饿汉式单例模式二（枚举实现）：

package cn.gof.singleton;
/**
 * @author zhaopan
 * @date 2016年10月21日 上午10:37:48
 * 枚举实现饿汉式单例模式
 * 优点：1、 自由序列化；2、 保证只有一个实例（即使使用反射机制也无法多次实例化一个枚举量）；3、 线程安全；
 * 缺点：无延时加载
 */
public enum Singleton02 {

	INSTANCE;
	public void sayHi(){
		System.out.println("我是枚举类型的单例");
	}
	
}

测试效率：

package cn.gof.singleton;
/**
 * @author zhaopan
 * @date 2016年10月21日 下午4:57:02
 * 
 */
import java.util.concurrent.CountDownLatch;  
  
/** 
 * 测试多线程环境下五种创建单例模式的效率 
 * @author liguodong 
 * 
 */  
public class ClientTest {  
    public static void main(String[] args) throws InterruptedException {  
          
        long start = System.nanoTime();  
        int threadNum = 10; 
        long sum=0;
        final CountDownLatch count = new CountDownLatch(threadNum);  
        int[] ins=new int[10];
        for(int j=0;j<100;j++) {        
	        for(int i=0;i<10;i++) {  
	            new Thread(new Runnable() {  
	                  
	                @Override  
	                public void run() {  
	                    // TODO Auto-generated method stub  
	                    for(int i=0;i<1000000;i++)  
	                    {  
	                    	/**
	                    	 * 饿汉式
	                    	 */
	                       // Object o = Singleton01.getInstance(); //普通饿汉式118755558---143202450
	                       //Object o = Singleton02.INSTANCE;//枚举式的111872193---163903002  大部分是11-13
	                    	/**
	                    	 * 懒汉式
	                    	 */
	                    	//Singleton03 instance = Singleton03.getInstance(); //方法加同步关键字2126685034
	                    	//Singleton04 instance2 = Singleton04.getInstance();//将方法内部加同步464849105
	                        //Object o = Singleton05.getInstance();  //内部类的方式  118638630--134209601
	                    }  
	                    count.countDown();  
	                      
	                }  
	            }).start();  
	        }  
        
	        count.await();//main线程阻塞，直到计数器变为0,才会继续往下执行。  
	        long end = System.nanoTime(); 
	        
	        sum=sum+end-start;
        }
        System.out.println("总耗时："+(sum/100));  
    }  
}  

比较两种模式？
单例对象  占用资源少，不需要延时加载：
枚举式好与 饿汉式
单例对象  占用资源大，需要延时加载：
静态内部类式好于懒汉式