设计模式之---单例模式

☺ 对于单例模式，个人学习需要掌握

• 注意答案的重点标黑了。对于单例模式，掌握，我下面这几点就很棒棒。

一、什么是单例模式：

在java中的定义是：一个类有且仅有一个实例，[单例]，并且自行实例化向整个系统提供。

二、实现单例的步骤：

1、构造器私有化，防止new，导致多个实例，而是在类内部创建对象

2、向外暴露一个静态的公共方法 getInstance

三、单例的方式

■ 单例模式有八种方式：

饿汉式(静态常量/静态代码块)

懒汉式(线程不安全/线程安全，同步方法/线程安全，同步代码块)

双重检查

静态内部类

枚举

★ 饿汉式和懒汉式区别：

饿汉式：在类内部一开始初始化时就创建好实例，而懒汉式是需要用的时候才去创建实例

■ 饿汉式(静态常量/静态代码块)

/**
* 饿汉式(静态常量)
*/
public class Singleton{
    private static final Singleton singleton  = new Singleton();//饿汉式，初始化时就创建好了实例[使用了final常量-->饿汉式(静态常量)]

    private Singleton(){}//构造器私有化，防止new，导致多个实例

    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        return singleton;
    }
}

/**
* 饿汉式(静态代码块)
*/
public class Singleton{
    private static Singleton singleton  = new Singleton();//饿汉式，初始化时就创建好了实例

    //代码块[使用了static代码块-->饿汉式(静态代码块)]
    static{
        singleton = new Singleton();
    }

    private Singleton(){}//构造器私有化，防止new，导致多个实例

    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        return singleton;
    }
}

■ 懒汉式(线程不安全/ 线程安全，同步方法 / 线程安全，同步代码块)

□ 懒汉式(线程不安全)

public class Singleton{
    private Singleton(){}//构造器私有化，防止new，导致多个实例
    private static Singleton singleton;
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }

}

□ 懒汉式(线程安全，同步方法)

public class Singleton{
    private Singleton(){}//构造器私有化，防止new，导致多个实例
    private static Singleton singleton;
    //同步方法，synchronized直接加在方法上
    public static synchronized Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }

}

□ 懒汉式(线程安全，同步代码块)

public class Singleton{
    private Singleton(){}//构造器私有化，防止new，导致多个实例
    private static Singleton singleton;
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        if(singleton == null){
            //同步代码块，synchronized是单独作为代码块使用
            synchronized (Singleton.class){
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

■ 双重检查

public class Singleton{
    private Singleton(){}//构造器私有化，防止new，导致多个实例
    private static volatile Singleton singleton;
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        //第一层检查
        if(singleton == null){
            //同步代码块
            synchronized (Singleton.class){
                 //第二层检查
                if(singleton == null) {
                    singleton = new Singleton();
                }
            }

        }
        return singleton;
    }

}

■ 静态内部类

public class Singleton{
    private Singleton(){}//构造器私有化，防止new，导致多个实例
    //静态内部类,在其内部以静态常量的方式实例化对象
    private static class SingletonInstance{
        private static final Singleton singleton = new Singleton();//常量静态属性，实例化对象[初始化]
    }
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        return SingletonInstance.singleton;
    }
}

■ 枚举方式

enum Singleton{
    INSTANCE;
    public void method(){
//            操作方法
    }

}

四、单例的使用场景

需要频繁的进行创建和销毁的对象、

创建对象时耗时过多或 耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等）

如果本文对你有帮助的话记得给一乐点个赞哦，感谢！