Java设计模式——单例模式

设计模式

单例模式

单例模式就是想办法让某个类只存在一个实例对象，并且该类只提供一个取得其对象实例的方法。单例模式的实现方式有很多种，列举几个常拿出来说的和几个在实际场景中能用到的。

懒汉式（静态常量）

特点；简单好写，但是实例化的对象需要用到，生产了不用就是浪费内存。

class Singletion1{
    //第一步私有化构造器,外部new不到
    private Singletion1(){}

    //第二步，创建静态常量对象实例化
    private final static Singletion1 instance = new Singletion1();

    //第三步提供一个共有的静态方法，返回实例对象
    public static Singletion1 getInstance(){
        return instance;
    }
}

懒汉式（静态变量）

特点:线程不安全，咱就别在生产环境中使用了。

class Singletion2 {
    //第一步私有化构造器,外部new不到
    private Singletion2() {
    }

    //第二步，创建静态常量，暂时不实例化
    private static Singletion2 instance;

    //第三步提供一个共有的静态方法，返回实例对象
    public static Singletion2 getInstance() {
        //快来看，就是它会造成线程不安全
        if (instance == null) {
            instance = new Singletion2();
        }
        return instance;
    }
}

懒汉式（同步方法 synchronized）

特点；线程安全，但是就是脱裤子放屁，因为没有把多线程的效率体现出来，人家要多线程提升效率，它把方法同步了，线程都卡在外面一个一个通过。

class Singletion3 {
    //第一步私有化构造器,外部new不到
    private Singletion3() {
    }

    //第二步，创建静态常量，暂时不实例化
    private static Singletion3 instance;

    //第三步提供一个共有的静态方法，返回实例对象,方法上加了一个synchronized
    public static synchronized Singletion3 getInstance() {
        if (instance == null) {
            instance = new Singletion3();
        }
        return instance;
    }
}

懒汉式（双重检查）

特点：线程安全，开发环境中强烈的推荐。

class Singletion4 {
    //第一步私有化构造器,外部new不到
    private Singletion4() {
    }

    //第二步，创建静态常量，暂时不实例化,用volatile修饰一下。
    // 当一个线程的instance对象被实例化后，其他线程的instance对象也会共享
    private volatile static Singletion4 instance;

    //第三步提供一个共有的静态方法，返回实例对象
    public static Singletion4 getInstance() {
        if (instance == null) {
            //这里防止instance对象实例化时会有多个线程一起进行
            synchronized (Singletion4.class) {
                if (instance == null) {
                    instance = new Singletion4();
                }
            }
        }
        return instance;
    }
}

静态内部类

特点：使用简单，线程安全，推荐使用

class Singletion5 {
    //第一步私有化构造器,外部new不到
    private Singletion5() {
    }

    //第二步，创建静态内部类，在内部类中实例化对象
    //利用静态内部类延迟加载的特点，保证了资源不会浪费，因为只有在使用getInstance()方法时才会加载静态内部类
    static class Singleton5Instance {
        private static Singletion5 instance = new Singletion5();
    }


    //第三步提供一个共有的静态方法，返回实例对象
    public static Singletion5 getInstance() {
        return Singleton5Instance.instance;
    }
}

枚举

特点：使用简单，线程安全，推荐使用

enum Singletion6{
    INSTANCE;
}

检验线程是否安全

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        int count = 10;
        Thread[] threads = new Thread[count];
        for (int i = 0; i < count; i++) {
            threads[i] = new Thread(() -> {
                Singletion6 instance = Singletion6.INSTANCE;
                //输出一样就是安全的
                System.out.println(instance.hashCode());
            });
            threads[i].start();
        }
        for (Thread thread : threads) {
            thread.join();
        }
    }
}