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

末蓝、 2022-07-15 16:11 213阅读 0赞

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

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

[单例的使用场景][Link 1]

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

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可以保证线程安全参考：

[单例模式与双重检测][Link 2]

[用happen-before规则重新审视DCL][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));  
        }  
    }

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

[Link 1]: http://blog.csdn.net/tanyujing/article/details/14160941
[Link 2]: http://www.iteye.com/topic/652440
[happen-before_DCL]: http://www.iteye.com/topic/260515