单例模式

单例模式

要点：

• 一是某个类只能有一个实例
  • 构造器私有化
• 二是它必须自行创建这个实例
  • 含有一个该类的静态变量来保存这个唯一的实例
• 三是它必须自行向整个系统提供这个实例
  • 对外提供获取该实例对象的方法
  • （1）直接暴露
  • （2）用静态变量的get方法获取

---

几种常见的形式

• 饿汉式：直接创建对象，不存在线程安全的问题

  • 直接实例化饿汉式（简洁直观）

    package singletondemo;
    
    /**
     * 饿汉式：
     * 在类初始化时直接创建实例对象,不管是否需要这个对象都会创建
     * (1)构造器私有化
     * (2)自行创建，并且用静态变量保存
     * (3)向外提供这个实例
     * (4)强调这是一个单例，我们可以用final修改
     */
    public class Singleton1 {
    	public static final Singleton1 INSTANCE = new Singleton1();
    	private Singleton1() {
    		
    	}
    }
    
    
    // 备注：可以直接通过类名.来访问
    

  • 枚举式（最简洁）

    package singletondemo;
    
    /**
     * 枚举类型：表示该类型的对象是有限的几个
     * 我们可以限定为一个，就成了单例
     */
    public enum Singleton2 {
    	INSTANCE
    }
    
    // 备注：可以通过类名.来访问
    

  • 静态代码块饿汉式（适合复杂实例化）

    package singletondemo;
    
    public class Singleton3 {
    	public static final Singleton3 INSTANCE;
    	static{
    		INSTANCE = new Singleton3();
    	}
    	private Singleton3() {
    		
    	}
    }
    // 备注：这个跟Singletion1是等效的，而且更复杂，试用于复杂的实例化
    

    package singletondemo;
    
    import java.io.IOException;
    import java.util.Properties;
    
    public class Singleton3 {
    	public static final Singleton3 INSTANCE;
    	private String info;
    	static{
    		try {
    			Properties pro = new Properties();
    			// 假设在src下有一个singleton.properties配置文件
    			// 文件中有个info属性
    			pro.load(Singleton3.class.getClassLoader().
    					getResourceAsStream("singleton.properties"));
    			INSTANCE = new Singleton3(pro.getProperty("info"));
    		} catch(IOException e) {
    			throw new RuntimeException(e);
    		}
    	}
    	private Singleton3(String info) {
    		this.info = info;
    	}
    	// 添加get set方法，toString()方法进行测试验证
    }
    
    // 直接通过类名.来访问，输出其get方法可得到配置文件中info的属性值
    

• 懒汉式：延迟创建对象

  • 线程不安全（适用于单线程）

    package singletondemo;
    
    /**
     * 懒汉式：
     *   延迟创建这个实例对象
     * (1)构造器私有化
     * (2)用一个静态变量保存这个唯一的实例
     * (3)提供一个静态方法，获取这个实例对象
     *
     */
    public class Singleton4 {
    	private static Singleton4 instance;
    	private Singleton4() {
    		
    	}
    	public static Singleton4 getInstance() {
    		if(instance == null) {
                // Thread.sleep(100)
    			instance = new Singleton4();
    		}
    		return instance;
    	}
    }
    
    /*
     * 这段代码是有可能发生线程安全问题的
     * 当第一个线程进来，不是null,到了休眠时间
     * 此时第二个线程进来，不是null,休眠
     * 线程一结束休眠，new 了一个对象
     * 线程二结束休眠，new 了一个对象
     * 所以，此时，两个对象是不一样的
     */
    

    测试

    package test;
    
    import singletondemo.Singleton4;
    
    public class Singleton4Test {
    	public static void main(String[] args) {
    		Singleton4 s1 = Singleton4.getInstance();
    		Singleton4 s2 = Singleton4.getInstance();
    		System.out.println(s1 == s2);
    		System.out.println(s1);
    		System.out.println(s2);
    	}
    }
    
    // 输出结果如下：
    // true
    // singletondemo.Singleton4@15db9742
    // singletondemo.Singleton4@15db9742
    

  • 线程安全（适用于多线程）

    package singletondemo;
    
    /**
     * 懒汉式：
     *   延迟创建这个实例对象
     * (1)构造器私有化
     * (2)用一个静态变量保存这个唯一的实例
     * (3)提供一个静态方法，获取这个实例对象
     *
     */
    public class Singleton5 {
    	private static Singleton5 instance;
    	private Singleton5() {
    		
    	}
    	public static Singleton5 getInstance() {
    		if(instance == null) {
    			synchronized (Singleton5.class) {
    				if(instance == null) {
    					// 休眠测试Thread.sleep(200)
    					instance = new Singleton5();
    				}
    			}
    		}
    		return instance;
    	}
    }
    
    

  • 静态内部类形式（适用于多线程）

    package singletondemo;
    
    /**
     * 在内部类被加载和初始化时，才创建INSTANCE实例对象
     * 静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独去加载和初始化的
     * 因为是在 内部类加载和初始化时创建的，因此是线程安全的
     */
    public class Singleton6 {
    	private Singleton6() {
    		
    	}
    	private static class Inner{
    		private static final Singleton6 INSTANCE = new Singleton6();
    	}
    	public static Singleton6 getInstance() {
    		return Inner.INSTANCE;
    	}
    }
    
    

---

总结

• 如果是饿汉式，枚举形式最简单
• 如果是懒汉式，静态内部类形式最简单
• 注意线程安全问题