1.单例设计模式(懒汉式,饿汉式,枚举式,双重检测锁式,静态内部类式)

ゝ一世哀愁。 2022-08-03 15:52 171阅读 0赞

设计模式分类:  
1：创建型模式：  
单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式；  
2：结构型模式：  
适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式  
3：行为型模式：  
模板方法模式，命令模式，迭代器模式，观察者模式，中介者模式，备忘录模式，  
解释器模式，状态模式，策略模式，职责链模式，访问者模式。

单例模式应用场景：  
windows的task manager(任务管理器)就是很典型的单例模式，  
windows的recycle bin(回收站)也是典型的单例应用，在整个系统运行过程中，回收站一直  
维护仅有的一个实例。  
项目中，读取配置文件的类，一般也只有一个对象，没有必要每次使用配置文件数据，每次  
new一个对象去读取，  
应用程序的日志应用，一般都可用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为  
只能有一个实例去操作，否则内容不好追加。  
数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源  
操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统  
Application也是单例的典型应用(servlet编程中会涉及到)  
在spring中，每个bean默认就是单例的，这样做的优点是spring容器可以管理  
在servlet编程中，每个servlet也是单例  
在spring mvc框架/struts1框架中，控制器对象也是单例

单例模式的实现（5种）  
常用:  
饿汉式(线程安全，调用效率高，但是不能延时加载)  
懒汉式（线程安全，调用效率不高，可以延时加载）  
其他：  
双重检测锁式（由于jvm底层内部模型原因，偶尔会出问题，不建立使用）  
静态内部类式（线程安全，调用效率高，但是可以延时加载）  
枚举单例（线程安全，调用效率高，不能延时加载）

常用恶汉式，懒汉式：

/**
     * 测试恶汉式单例模式
     * @author Administrator
     *
     */
    public class SingleTonDemo1 {
    	
    	//类初始化时，立即加载对象。天然的线程安全的
    	private static SingleTonDemo1 instance = new SingleTonDemo1(); //类初始化时，立即加载
    	
    	private SingleTonDemo1() {
    		
    	}
    	
    	//方法没有同步，调用效率高
    	public static SingleTonDemo1 getInstance() {
    		return instance;
    	}
    }

/**
     * 测试懒汉式单例模式
     * @author Administrator
     *
     */
    public class SingleTonDemo2 {
    	
    	private static SingleTonDemo2 instance = null;
    	
    	private SingleTonDemo2() {
    		
    	}
    	
    	//方法使用同步，调用效率低
    	public static synchronized SingleTonDemo2 getInstance() {
    		if(instance == null) {
    			instance = new SingleTonDemo2();
    		}
    		return instance;
    	}
    	
    }

/**
     * 枚举单例模式
     * @author Administrator
     *
     */
    public enum SingleTonDemo4 {
    	INSTANCE; //虽然只有一行
    }

public class TestEnum {
    	
    	//测试枚举单例
    	public static void main(String[] args) {
    		SingleTonDemo4 instance1 = SingleTonDemo4.INSTANCE;
    		SingleTonDemo4 instance2 = SingleTonDemo4.INSTANCE;
    		SingleTonDemo4 instance3 = SingleTonDemo4.INSTANCE;
    		
    		System.out.println(instance1 == instance3);
    	}
    	
    }

/**
     * 静态内部类式单例设计模式
     * @author Administrator
     *
     */
    public class SingleTonDemo3 {
    	
    	//只会被加载一次，线程安全
    	static class Nested {
    		private  static SingleTonDemo3 instance = new SingleTonDemo3();
    	}
    	
    	private SingleTonDemo3() {
    		
    	}
    	
    	public static SingleTonDemo3 getInstance() {
    		return Nested.instance;
    	}
    }

<p>/**
     * 双重检测锁式单例设计模式
     * @author Administrator
     *
     */
    public class SingleTonDemo5 {</p><p>    private static volatile SingleTonDemo5 instance;
       
        private SingleTonDemo5() {
         
        }
     
        //getInstance()方法检查了两次来判断INSTANCE是否为null，这就是为什么叫双检索的原因，
        //记住双检索在java5之前是有问题的，但是java5在内存模型中有了volatile变量之后就没问题了
        public static SingleTonDemo5 getInstance(){
            if(instance == null){
               synchronized(SingleTonDemo5.class){
                   if(instance == null){
                    instance = new SingleTonDemo5();
                   }
               }
            }
            return instance;
        }
        
    }</p>