设计模式之单例设计模式

单例设计模式（饿汉式静态变量）

public class SingleTest1 {
    @Test
    public void test(){
        //通过调用静态方法来创建实例
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        //证明不管多少次调用Singleton类同一个实例
        System.out.println(instance==instance1);//true

    }
}
//饿汉式（静态变量）
//优点：这种写法比较简单，在类装载的时候就完成了实例化，避免了线程同步的问题
//缺点：没有实现lazy loading的效果，实例创建可能不会被使用，导致内存的浪费
class Singleton{
    //私有化构造方法，目的：不让外界随便创建实例
    private Singleton(){

    }
    //本类部自己创建实例
    private static Singleton instance = new Singleton();
    //对外界提供公共的静态方法，返回实例的对象
    public static Singleton getInstance(){
        return instance;
    }
}

饿汉式（静态代码块）

public class SingleTest2 {
    @Test
    public void test() {
        //通过调用静态方法来创建实例
        Singleton2 instance = Singleton2.getInstance();
        Singleton2 instance1 = Singleton2.getInstance();
        //证明不管多少次调用Singleton类同一个实例
        System.out.println(instance == instance1);//true

    }
}

//饿汉式（静态代码块）
//优点：这种写法比较简单，在类装载的时候就完成了实例化，避免了线程同步的问题
//缺点：没有实现lazy loading的效果，实例创建可能不会被使用，导致内存的浪费
class Singleton2 {
    //私有化构造方法，目的：不让外界随便创建实例

    private Singleton2() {

    }

    //在本类中声明实例
    private static Singleton2 instance;

    static {
        //在静态代码块中实例化对象
        instance = new Singleton2();
    }

    //对外界提供公共的静态方法，返回实例的对象
    public static Singleton2 getInstance() {
        return instance;
    }
}

---

单例设计模式（懒汉式线程不安全）

public class SingleDemo2 {
    @Test
    public void test() {
        //通过调用静态方法来创建实例
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        //证明不管多少次调用Singleton类同一个实例
        System.out.println(instance == instance1);//true

    }
}
//懒汉式（多线程不安全）
class Singleton {

    private static Singleton instance;
    //私有化构造方法
    private Singleton() {

    }
    //需要时再创建对象
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class SingleDemo2 {
    @Test
    public void test() {
        //通过调用静态方法来创建实例
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        //证明不管多少次调用Singleton类同一个实例
        System.out.println(instance == instance1);//true

    }
}
//懒汉式（线程安全）
//优点：解决了线程安全的问题
//缺点：效率太低,不推荐使用

class Singleton {
    
    private static Singleton instance;
    //私有化构造方法
    private Singleton() {

    }
    //需要时再创建对象,提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

双重检查

解决了多线程安全问题

public class SingleDemo2 {
    @Test
    public void test() {
        //通过调用静态方法来创建实例
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        //证明不管多少次调用Singleton类同一个实例
        System.out.println(instance == instance1);//true

    }
}

// 双重检查 
class Singleton {
//volatile防止指令重排推荐使用
    private static volatile Singleton instance;

    //私有化构造方法
    private Singleton() {

    }

    //需要时再创建对象
    public static synchronized Singleton getInstance() {
        //第一次检查
        if (instance == null) {
            synchronized (Singleton.class) {
                //第二次检查
                if (instance == null) {
                    instance = new Singleton();
                }
            }

        }
        return instance;
    }
}

静态内部类

利用jvm的装载机制，当类加载时静态内部类不会立即被加载，保证了线程安全以及效率的问题

public class SingleDemo2 {
    @Test
    public void test() {
        //通过调用静态方法来创建实例
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        //证明不管多少次调用Singleton类同一个实例
        System.out.println(instance == instance1);//true

    }
}

//静态内部类
class Singleton {

    private static volatile Singleton instance;

    //私有化构造方法
    private Singleton() {

    }

    private static class SingleInstance {
        private static final Singleton instance = new Singleton();
    }

    //需要时再创建对象,提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    public static synchronized Singleton getInstance() {
        return SingleInstance.instance;
    }

}

枚举

使用枚举，可以实现单例，推荐使用，还能防止反序列化创建对象

public class SingletonTest8 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance1 = Singleton.INSTANCE;
        System.out.println(instance == instance1);//true
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());

    }
}

enum Singleton {
    INSTANCE;//属性

    public void sayOk() {

    }
}