单例设计模式

概述

Singleton 单例设计模式，即某个类在整个系统中只能有一个实例对象可被获取和使用的代码模式。

特点

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

几种常见形式

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

 直接实例化饿汉式（简洁直观）
  枚举式（最简洁）
  静态代码块饿汉式（适合复杂实例化）

二、懒汉式：延迟创建对象

  线程不安全（适用于单线程）
  线程安全（适用于多线程）
  静态内部类形式（适用于多线程）

直接上例子：
首先饿汉式，直接实例化饿汉式：

/** 懒汉式
 * 在类初始化时直接创建实例对象，不管你是否需要这个对象都会创建
 * 1)构造器私有化
 * 2)自行创建，并且使用静态变量保存
 * 3）向外提供这个实例
 * 4)强调这是一个单例，我们可以用final修饰
 */
public class Singleton1 {
    public static final Singleton1 INSTANCE=new Singleton1();
    private Singleton1(){

    }
}

枚举类型

/**简介型：枚举类型
 * 表示该类型的对象是有限的几个
 * 我们可以限定为一个，就成了单例
 */
public enum Singleton2 {
    INSTANCE
}

静态代码块式

/**静态代码块的状态
 * 运用在配置文件中
 */
public class Singleton3 {
    public static final Singleton3 INSTANCE;
    private String info;
    static{
        Properties pro=new Properties();
        try {
            pro.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));
            INSTANCE=new Singleton3(pro.getProperty("info"));
        } catch (IOException e) {
           throw new RuntimeException(e);
        }
    }
    private Singleton3(String info){
        this.info=info;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Singleton3{" +
                "info='" + info + '\'' +
                '}';
    }
}

懒汉式

/**懒汉式：
 * 1）构造器私有化
 * 2）用一个静态保存这个唯一的实例
 * 3)提供一个静态方法，获取这个实例对象
 */
public class Singleton4 {
    private static Singleton4 instance;
    private Singleton4(){
    }
    public static Singleton4 getInstance(){
        if(instance==null){
            instance=new Singleton4();
        }
        return instance;
    }
}

这种写法存在线程不安全问题，主要问题是发生在为实例化时多个线程同时访问，而创建不同的实例而导致线程不安全，为了线程安全可以修改如下：

public class Singleton5 {
    private static Singleton5 instance;
    private Singleton5(){
    }
    public static Singleton5 getInstance(){
        if(instance ==null) {//为了效率
            synchronized (Singleton5.class) {
                if (instance == null) {
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance = new Singleton5();
                }
            }
        }
        return instance;
    }
}

懒汉式：简洁的线程安全

/**在内部类被加载初始化时，才创建INSTACNE实例对象
 * 静态内部类不会自动随着外部类的加载初始化而初始化，他是要单独去加载和初始化的。
 * 因为是在内部类加载和初始化时，创建的，因此是线程安全的
 * @author Zhangxinxin
 */
public class Singleton6 {
    private Singleton6(){

    }
    private static class Inner{
        private static Singleton6 INSTANCE=new Singleton6();
    }
    public static Singleton6 getInstance(){
        return Inner.INSTANCE;
    }
}