单例模式的七种写法

单例模式的七种写法

写前须知

单例模式，顾名思义是一种在程序运行过程中只会产生一个对象实例的设计模式。因此设计之前，我们需要知道最基本的条件：
1.构造函数私有化
2.实例引用私有化
3.获取实例公有化。

单例模式可以分为懒汉单例模式和饿汉单例模式。就像这形象的名字描述的那样
1.懒汉单例模式只会在我们需要的时候才回去创建对象实例
2.饿汉单例模式则在程序启动时就创建好了对象实例

然后就开始我们的单例模式设计吧！

一、线程不安全的懒汉单例模式

应用场景：单线程

public class Singleton_1 {
    private static Singleton_1 instance;
    //构造方法私有化
    private Singleton_1(){
        //执行几次就创建了多少实例
        System.out.println("Singleton_1");
    }
	//调用此方法才会创建对象实例
    public static Singleton_1 getInstance(){
        if (instance==null){
            instance = new Singleton_1();
        }
        return instance;
    }
}

测试一下

class TestSingleton_1{
    public static void main(String[] args) {
        Singleton_1.getInstance();
        Singleton_1.getInstance();
        Singleton_1.getInstance();
//        for (int i=0;i<100;i++){
//            new Thread(){
//                @Override
//                public void run() {
//                    Singleton_1.getInstance();
//                }
//            }.start();
//        }
    }
}

结果如下：

很明显只创建了一个实例。
好奇的童鞋们可以自己测试一下注释部分的多线程情况下会发生什么

二、线程安全的懒汉单例模式

应用场景：大对象，用的少，并发量不能太大

public class Singleton_02 {
    private static Singleton_02 instance;
    private Singleton_02(){
        System.out.println("Singleton_2");
    }
    //线程安全但是性能降低
    public static synchronized Singleton_02 getInstance(){
        if (instance==null)
            instance = new Singleton_02();
        return instance;
    }
}

并发量太大的话可能会造成性能问题。
测试一下：

class TestSingleton_2{
    public static void main(String[] args) {
        for (int i=0;i<1000;i++){
            new Thread(){
                @Override
                public void run() {
                    Singleton_02.getInstance();
                }
            }.start();
        }
    }
}

结果如图：

三、双重验证的懒汉单例模式

应用场景：大对象，稀少用，并发量不能太大

public class Singleton_3 {
    //注意这里用volatile修饰
    private static volatile Singleton_3 instance;

    private Singleton_3(){
        System.out.println("Singleton_3");
    }

    public static Singleton_3 getInstance(){
    	//双重验证
        if (instance==null){
            synchronized (Singleton_3.class){
                if (instance==null)
                    instance=new Singleton_3();
            }
        }
        return instance;
    }
}

1.在并发条件下，最先到达外层 if 判断语句的线程进入语句体后（这里可能有多个线程进入外层 if 语句，因此才会有第二层 if 语句）获得锁，第一个获得锁的线程明显判定 instance==null ，因此进入第二层 if 语句然后创建对象实例赋值给instance。
2.后面的线程（无论是在第一层 if 语句，还是已经进入外层 if 语句）都会判断intance是否为null（此时明显不为null），因此节省了大量时间在获得锁，释放锁的过程（并发不高的条件下，毕竟一拥而入外层 if 语句的线程并不多），相对第二种设计方式，性能较大提升。

相信大家读到这也能理解为什么instance要用volatile修饰了——为了保证它的可见性

测试一下：

class TestSingleton_3{
    public static void main(String[] args) {
        for (int i=0;i<1000;i++){
            new Thread(){
                @Override
                public void run() {
                    Singleton_3.getInstance();
                }
            }.start();
        }
    }
}

四、饿汉单例模式

应用场景：小对象，频繁用,高并发

public class Singleton_4 {
    //对象在类加载时初始化
    private static Singleton_4 instance = new Singleton_4();
    private Singleton_4(){
        System.out.println("Singleton_4");
    }

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

对象实例用static修饰，在类加载时就已经初始化，因此被称为饿汉单例。

测试：

class TestSingleton_4{
    public static void main(String[] args) {
        for (int i=0;i<1000;i++) {
            new Thread() {
                @Override
                public void run() {
                    Singleton_4.getInstance();
                }
            }.start();
        }
    }
}

五、基于内部类实现的单例模式

应用场景：大对象，频繁用，高并发

public class Singleton_5 {
	//内部类
    static class Inner{
        private final static Singleton_5 instance = new Singleton_5();
    }
    private Singleton_5(){
        System.out.println("Singleton_5");
    }

    public static Singleton_5 getInstance(){
        return Inner.instance;
    }
}

内部类只会在使用时加载，不使用不加载，因此可以很好的实现单例模式

测试：

class TestSingleton_5{
    public static void main(String[] args) {
        for (int i=0;i<1000;i++) {
            new Thread() {
                @Override
                public void run() {
                    Singleton_5.getInstance();
                }
            }.start();
        }
    }
}

六、枚举实现单例模式

public enum Singleton_6 {
    INSTANCE;//一个实例（类加载时创建）
    private C c;
    private Singleton_6(){
        c = new C();
    }
    public C getInstance(){
        return c;
    }
}

class C{
    public C(){
        System.out.println("C-Singleton_6");
    }
}

测试：

class TestSingleton_6{
    public static void main(String[] args) {
        for (int i=0;i<1000;i++){
            new Thread(){
                @Override
                public void run() {
                    Singleton_6.INSTANCE.getInstance();
                }
            }.start();
        }
    }
}

七、使用“池”实现单例模式

class A{public A(){System.out.println("A");}}
class B{public B(){System.out.println("B");}}

public class Singleton_7 {//思考spring的单例设计
    public static Map<String,Object> map = new HashMap<>();
    static {
        map.put("A",new A());
        map.put("B",new B());
    }
    public static Object get(String key){
        return map.get(key);
    }
}

测试：

class TestSingleton_7{
    public static void main(String[] args) {
        for (int i=0;i<1000;i++) {
            new Thread() {
                @Override
                public void run() {
                    Singleton_7.get("A");
                    Singleton_7.get("B");
                }
            }.start();
        }
    }
}

结果如下：

结束语

好好学习，天天向上！Fighting小伙汁们！！！