23种设计模式之创建型模式 - 单例模式

文章目录

一、单例模式
- 1.1单例模式定义
- [1.2 单例模式的特点](#1.2 单例模式的特点)
二、实现单例模式的方式
- [2.1 饿汉式](#2.1 饿汉式)
- [2.2 懒汉式](#2.2 懒汉式)
- [2.3 双重检查锁：](#2.3 双重检查锁：)
- [2.4 静态内部类](#2.4 静态内部类)
- [2.5 枚举实现（防止反射攻击）：](#2.5 枚举实现（防止反射攻击）：)

一、单例模式

1.1单例模式定义

单例模式确保系统中某个类只有一个实例，并提供一个访问它的全局访问点。主要解决一个全局使用的类频繁地创建与销毁，控制实例数目，节省系统资源。

1.2 单例模式的特点

单例类只能有一个实例
单例类必须自己创建自己的唯一实例
单例类必须给所有其他对象提供这一实例
单例模式保证了全局对象的唯一性，比如系统启动读取配置文件就需要单例保证配置的一致性

单例的四大原则：

构造私有
以静态方法或者枚举返回实例
确保实例只有一个，尤其是多线程环境
确保反序列换时不会重新构建对象

二、实现单例模式的方式

2.1 饿汉式

饿汉式单例在类加载初始化时就创建好一个静态的对象供外部使用，除非系统重启，这个对象不会改变，所以本身就是线程安全的。

Singleton 通过将构造方法限定为 private 避免了类在外部被实例化，在同一个虚拟机范围内，Singleton 的唯一实例只能通过 getInstance()方法访问。（事实上，通过 Java 反射机制是能够实例化构造方法为 private 的类的，会使 Java单例实现失效）

java 复制代码

/**
 * @Author huang.bX
 * @Date 2021/7/21
 */
public class SingletonTest01 {
    public static void main(String[] args) {
        Hungry instance = Hungry.getInstance();
        Hungry instance1 = Hungry.getInstance();
        Hungry instance2 = Hungry.getInstance();
        System.out.println(instance.getClass());
        System.out.println(instance1.getClass());
        System.out.println(instance2.getClass());
    }
}

//饿汉式
class Hungry {
    //1构造器私有化，外部不能直接new
    private Hungry() {
    }
    //2本类的内部创建实例
    private final static Hungry hungry = new Hungry();

    //提供一个全局访问点共有的静态方法 返回实例对象
    public static Hungry getInstance(){
        return hungry;
    }
}

2.2 懒汉式

该示例虽然用延迟加载方式实现了懒汉式单例，但在多线程环境下会产生多个 Singleton 对象；

java 复制代码

/**
 * @Author huang.bX
 * @Date 2021/7/21
 */
public class SingletonTest03 implements Runnable {

    @Override
    public void run(){
        for (int i=1;i<1000;i++){
            LazyMan lazyMan=LazyMan.getInstance();
            System.out.println(lazyMan.hashCode());
        }
    }
    public static void main(String[] args) {
        /*
         *   LazyMan instance1 = LazyMan.getInstance();
         *   LazyMan instance2 = LazyMan.getInstance();
         *  System.out.println(instance1.hashCode()==instance2.hashCode());
        */
       new Thread(new SingletonTest03()).start();
       new Thread(new SingletonTest03()).start();
       new Thread(new SingletonTest03()).start();


    }
}

class LazyMan{
    private LazyMan(){

    }
    private static LazyMan lazyMan;

    //public static LazyMan getInstance()线程不安全
    public static synchronized LazyMan getInstance(){
        if (lazyMan==null){
           lazyMan = new LazyMan();
        }
        return lazyMan;
    }
}

2.3 双重检查锁：

使用双重检查锁进一步做了优化，可以避免整个方法被锁，只对需要锁的代码部分加锁，可以提高执行效率。

java 复制代码

/**
 * @Author huang.bX
 * @Date 2021/7/21
 */
public class SingletonTest05 {
    public static void main(String[] args) {
        DoubleLock instance1 = DoubleLock.getInstance();
        DoubleLock instance2 = DoubleLock.getInstance();
        System.out.println(instance1.hashCode()==instance2.hashCode());
    }
}

class DoubleLock{

    private static volatile DoubleLock doubleLock;
    private DoubleLock(){}

    public static DoubleLock getInstance(){
        if (doubleLock==null){
            synchronized (DoubleLock.class){
                if (doubleLock==null){
                    doubleLock = new DoubleLock();
                }
            }
        }
        return doubleLock;
    }
}

2.4 静态内部类

这种方式引入了一个内部静态类（static class），静态内部类只有在调用时才会加载，它保证了 Singleton 实例的延迟初始化，又保证了实例的唯一性。它把 singleton 的实例化操作放到一个静态内部类中，在第一次调用 getInstance() 方法时，JVM 才会去加载 InnerObject 类，同时初始hsingleton 实例，所以能让 getInstance() 方法线程安全。特点是：即能延迟加载，也能保证线程安全。静态内部类虽然保证了单例在多线程并发下的线程安全性，但是在遇到序列化对象时，默认的方式运行得到的结果就是多例的。

java 复制代码

/**
 * @Author huang.bX
 * @Date 2021/7/21
 */
public class SingletonTest06 {
    public static void main(String[] args) {
        StaticInClass instance1 = StaticInClass.getInstance();
        StaticInClass instance2= StaticInClass.getInstance();
        System.out.println(instance1.hashCode()==instance2.hashCode());
    }
}

class StaticInClass{

    private static volatile StaticInClass staticInClass;
    //构造器私有化
    private StaticInClass(){}

    //定义一个静态内部类，该类中有一个静态属性
    private static class Inner{
        private static final StaticInClass INSTANCE = new StaticInClass();
        
    }
    public static synchronized StaticInClass getInstance(){
        return Inner.INSTANCE;
    }

}

2.5 枚举实现（防止反射攻击）：

事实上，通过 Java 反射机制是能够实例化构造方法为 private 的类的。这也就是我们现在需要引入的枚举单例模式。

java 复制代码

/**
 * @Author huang.bX
 * @Date 2021/7/21
 */
public class SingletonTest07 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
        System.out.println(instance2.hashCode()==instance1.hashCode());
        System.out.println(instance1.getClass());
        System.out.println(instance2.getClass());
        System.out.println(instance1.getDeclaringClass());
    }
}

enum Singleton{
    INSTANCE;//属性
    public void say(){
        System.out.println("ok!");
    }
}