大话--单例模式

定义

保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。

优点

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。

2、避免对资源的多重占用（比如写文件操作）。

缺点

没有接口，扩展困难。

使用场景

需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据源、session工厂等）。

tips

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

关键代码

构造器一定是私有的

类图

使用单例模式的源码

java.lang.Runtime就使用了饿汉式的单例模式，因为Runtime一定会被使用，所以不会造成资源浪费。

具体实现

1.饿汉式（静态常量）

package Singleton.Singletontest1;

/**
 * @title: Singleton1
 * @Author yzhengy
 * @Date: 2020/7/30 20:22
 * @Question: 饿汉式（静态常量）
 */

/*
 * @Date: 2020/7/30 20:23
 * 1.构造器私有化（防止new对象）
 * 2.类的内部创建对象
 * 3.向外暴露一个静态的公共方法（getInstance）
 * 优点：类装载时就完成了实例化，避免了多线程同步问题。
 * 缺点：没有达到懒加载效果，如果一直不使用这个实例，会造成内存的浪费。
 */
public class Singleton1 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);//true
        System.out.println(instance.hashCode()==instance2.hashCode());//true
    }
}


class Singleton{
    private Singleton(){}

    private final static Singleton instance = new Singleton();

    public static Singleton getInstance(){
        return instance;
    }
}

2.饿汉式（静态代码块）

package Singleton.Singletontest2;

/**
 * @title: Singleton2
 * @Author yzhengy
 * @Date: 2020/7/30 20:34
 * @Question: 饿汉式（静态代码块）
 */

/*
 * @Date: 2020/7/30 20:23
 * 1.构造器私有化（防止new对象）
 * 2.类的内部创建对象实例
 * 3.在静态代码块中创建单例对象
 * 4.向外暴露一个静态的公共方法（getInstance）
 * 优缺点：与饿汉式（静态常量）的优缺点相同
 */
public class Singleton2 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);//true
        System.out.println(instance.hashCode()==instance2.hashCode());//true
    }
}


class Singleton{
    private Singleton(){}

    private static Singleton instance;

    static{
        instance = new Singleton();
    }

    public static Singleton getInstance(){
        return instance;
    }
}

3.懒汉式（线程不安全）

package Singleton.Singletontest3;

/**
 * @title: Singleton3
 * @Author yzhengy
 * @Date: 2020/7/31 8:35
 * @Question: 懒汉式（线程不安全）
 */

/*
 * @Date: 2020/7/31 8:41
 * 起到了懒加载的效果，但是只能在单线程时使用。
 * 如果在多线程时使用，一个线程进入了if(instance==null)判断语句块，还未来得及往下执行，
 * 另一个线程也通过了这个判断语句，这时就会产生多个实例。就会破坏单例模式。
 */
public class Singleton3 {

    public static void main(String[] args) {
        System.out.println("我是线程不安全的懒汉式！！！");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);//true
        System.out.println(instance.hashCode()==instance2.hashCode());//true
    }

}

class Singleton{
    private Singleton(){}

    private static Singleton instance;

    //提供一个静态公有方法，当时用到该方法时，才会创建instance。（懒汉式的核心）
    public static Singleton getInstance(){
        if (instance == null)
            instance = new Singleton();
        return instance;
    }
}

4.懒汉式（线程安全，同步方法）

package Singleton.Singletontest4;

/**
 * @title: Singleton4
 * @Author yzhengy
 * @Date: 2020/7/31 8:47
 * @Question: 懒汉式（线程安全，同步方法）
 */

/*
 * @Date: 2020/7/31 8:47
 * 在线程不安全的懒汉式的基础上，直接加一个Synchronized锁，保证线程安全。
 * 缺点：每个线程想获取类的实例时，执行getInstance()方法都要进行同步，方法同步效率太低。
 *      其实这个方法执行一次实例化代码就可以了，后面想获取该类实例直接return就可以了。
 */
public class Singleton4 {

    public static void main(String[] args) {
        System.out.println("我是线程安全的懒汉式！！！");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);//true
        System.out.println(instance.hashCode()==instance2.hashCode());//true
    }

}

class Singleton{
    private Singleton(){}

    private static Singleton instance;

    //提供一个静态公有方法，当时用到该方法时，才会创建instance。（懒汉式的核心）
    public static synchronized Singleton getInstance(){
        if (instance == null)
            instance = new Singleton();
        return instance;
    }
}

5.懒汉式（线程不安全，同步代码块）

package Singleton.Singletontest5;

/**
 * @title: Singleton5
 * @Author yzhengy
 * @Date: 2020/7/31 8:52
 * @Question: 懒汉式（线程不安全，同步代码块）
 */

/*
 * @Date: 2020/7/31 8:55
 * 与懒汉式线程不安全会有同样的问题，可能在多线程环境下创建多个实例。
 */
public class Singleton5 {

    public static void main(String[] args) {
        System.out.println("我是线程不安全的懒汉式2！！！");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);//true
        System.out.println(instance.hashCode()==instance2.hashCode());//true
    }

}

class Singleton{
    private Singleton(){}

    private static Singleton instance;

    //提供一个静态公有方法，当时用到该方法时，才会创建instance。（懒汉式的核心）
    public static Singleton getInstance(){
        if (instance == null)

            synchronized (Singleton.class){
            instance = new Singleton();}

        return instance;
    }
}

6.双重检查

package Singleton.Singletontest6;

/**
 * @title: Singleton6
 * @Author yzhengy
 * @Date: 2020/7/31 9:09
 * @Question: 双重检查--推荐使用
 */
public class Singleton6 {
    public static void main(String[] args) {
        System.out.println("我是双重检查");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);//true
        System.out.println(instance.hashCode()==instance2.hashCode());//true
    }
}

/*
 * @Date: 2020/7/31 9:16
 * 线程安全；延迟加载；效率较高；
 */
class Singleton{
    private Singleton(){}

    private static volatile Singleton instance;

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

7.静态内部类

package Singleton.Singletontest7;

/**
 * @title: Singleton7
 * @Author yzhengy
 * @Date: 2020/7/31 9:18
 * @Question: 静态内部类--推荐使用
 */
public class Singleton7 {
    public static void main(String[] args) {
        System.out.println("我是静态内部类");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);//true
        System.out.println(instance.hashCode()==instance2.hashCode());//true
    }
}
/*
 * @Date: 2020/7/31 9:20
 * 外部类被装载时，静态内部类并不会被装载。
 * 当调用getInstance时才会使静态内部类被装载，而且只会装载一次，装载时线程安全。
 * 优点：线程安全，利用静态内部类特点实现延迟加载，效率高。
 */
class Singleton{
    private Singleton(){}

    //静态内部类，该类中有一个静态属性Singleton
    private static class SingletonInstance{
        private final static Singleton INSTANCE = new Singleton();
    }

    //提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

8.枚举

package Singleton.Singletontest8;

/**
 * @title: Singleton8
 * @Author yzhengy
 * @Date: 2020/7/31 9:30
 * @Question: 枚举--推荐使用
 */
public class Singleton8 {
    public static void main(String[] args) {
        System.out.println("我是枚举");
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);//true
        System.out.println(instance.hashCode()==instance2.hashCode());//true

        instance.sayOK();
    }
}
/*
 * @Date: 2020/7/31 9:34
 * 使用枚举可以实现单例
 * 不仅可以避免多线程同步问题，还能防止反序列化重新创建新的对象。（其他方法则需要使用transient关键字）
 * 可以防止反射攻击。
 */
enum Singleton{
    INSTANCE;
    public void sayOK(){
        System.out.println("ok");
    }
}