Java设计模式 单例模式

单例模式

定义

所谓单例，就是整个程序某个类有且仅有一个实例。该类负责创建自己的对象，同时确保只有一个对象被创建。

特点

• 类构造器私有
• 持有自己类型的私有属性
• 对外提供获得实例的静态方法

几种类型

饿汉式

• 类加载到内存后，就实例化一个单例，jvm保证线程安全
• 优点: 简单易用,
• 缺点：不管用到与否，类装载时就完成实例化，可能会造成资源的浪费

/**
 * 饿汉模式
 * @author manzuo
 * @date 2020/6/4 16:04
 */
public class Singleton1 {
    /*持有自己类型的私有属性*/
    private static final Singleton1 INSTANCE = new Singleton1();
    /*类构造器私有*/
    private Singleton1(){};
    /*对外提供获得实例的静态方法*/
    public static Singleton1 getInstance(){
        return INSTANCE;
    }

    public static void main(String[] args) {
        Singleton1 s1 =Singleton1.getInstance();
        Singleton1 s2 =Singleton1.getInstance();
        System.out.println(s1==s2);
    }

}

懒汉式

• 优点:用到的时候才会加载
• 缺点:多线程的情况下不安全

/**
 * lazy loading
 * 懒汉式

 *
 * @author manzuo
 * @date 2020/6/4 22:53
 */
public class Singleton2 {
    private static  Singleton2 INSTANCE;
    private Singleton2(){};
    public static Singleton2 getInstance(){
        if (INSTANCE == null){
            INSTANCE = new Singleton2();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()-> System.out.println(Singleton2.getInstance().hashCode())).start();
        }
    }
}

• 为了解决线程安全做出的改进,通过双重检测锁模式保证了多线程下也只存在一个单例.

public class Singleton2 {
    private static volatile Singleton2 INSTANCE;
    private Singleton2(){};
    public static Singleton2 getInstance(){
        if (INSTANCE == null){
            //可以通过synchronized解决线程安全问题
            synchronized (Singleton2.class){
                if (INSTANCE==null){
                    INSTANCE = new Singleton2();
                }
            }
        }
        return INSTANCE;
    }
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()-> System.out.println(Singleton2.getInstance().hashCode())).start();
        }
    }
}

• 但是双重检测锁模式也不是绝对安全的,可以通过反射来破坏.

import java.lang.reflect.Constructor;
public class Singleton2 {
    private static volatile Singleton2 INSTANCE;
    private Singleton2(){};
    //DCL 懒汉式
    public static Singleton2 getInstance(){
        if (INSTANCE == null){
            //可以通过synchronized解决线程安全问题
            synchronized (Singleton2.class){
                if (INSTANCE==null){
                    INSTANCE = new Singleton2();
                }
            }
        }
        return INSTANCE;
    }
    public static void main(String[] args) throws Exception {
        //通过反射可以破坏DCL（双重锁检测）懒汉式 单例模式
        Class c1 = Singleton2.class;
        //获取默认无参构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor();
        //关闭安全检测,以便访问私有构造器
        declaredConstructor.setAccessible(true);
        //生成实例
        Singleton2 instance = (Singleton2) declaredConstructor.newInstance();
        Singleton2 instance1 =(Singleton2)declaredConstructor.newInstance();
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

静态内部类方式

• JVM保证了单例以及线程安全
• 加载外部类的时候不会加载内部类,实现了懒加载
• 但还是会被反射给破坏（通过反射调用私有的构造方法）

/**

 *
 * @author manzuo
 * @date 2020/6/5 1:34
 */
public class Singleton3 {
    private Singleton3(){}
    private static class Singleton3Inner{
        private final static Singleton3 INSTANCE = new Singleton3();
    }
    public static Singleton3 getInstance(){
        return Singleton3Inner.INSTANCE;
    }
     public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()-> System.out.println(Singleton3.getInstance().hashCode())).start();
        }
    }
}

枚举单例

• enum本身也是一个Class类，不仅可以解决线程安全问题，也可以防止反序列化，而且还可以防止反射破坏单例

/**
 * 出自《Effective Java》
 * 不仅可以解决线程安全问题，也可以防止反序列化
 * @author manzuo
 * @date 2020/6/5 1:45
 */
public enum  Singleton4 {
    INSTANCE;

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()-> System.out.println(Singleton4.INSTANCE.hashCode())).start();
        }
    }
}