1.Java单例设计模式

单例设计模式

一些人总结出来用来解决特定问题的固定的解决方案。

解决一个类在内存中只存在一个对象，想要保证对象的唯一。

1 为了避免其他程序过多的建立该类对象。禁止其他程序建立该类对象。

2 为了其他程序可以访问该类对象，在本类中自定义一个对象。

3 方便其他程序对自定义类的对象的访问，对外提供一些访问方式。

单类设计模式需求：

代码：

1将构造函数私有化

2在类中创建一个私有的本类对象

3提供一个用类名调用的公有方法获取该对象。

class Single {
    
    private static Single s = new Single(); // 恶汉式,在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

    private Single() {}

    public static Single getInstance() {
        return s;
    }
}

class Single2 {
    private static Single2 s = null; // 懒汉式，这种懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例

    private Single2() {}

    public static Single2 getInstance() {
        if (s == null) {
            s = new Single2();
        }
        return s;
    }
}

单类设计模式-懒汉式-线程安全：

以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全，如果你第一次接触单例模式，对线程安全不是很了解，可以先跳过下面这三小条，去看饿汉式单例，等看完后面再回头考虑线程安全的问题：

1、在getInstance方法上加同步（性能较差）

class Single2 {
    private static Single2 s = null; // 懒汉

    private Single2() {

    }

    public static synchronized  Single2 getInstance() {
        if (s == null) {
            s = new Single2();
        }
        return s;
    }
}

2、双重检查锁定（DCL 双检查锁机制）推荐

class Single2 {
    private static Single2 s = null; // 懒汉

    private Single2() {

    }

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

3、静态内部类推荐

class Single2 {
    private static class LazyHolder{
        private static final Single2 s = new Single2()
    }

    private Single2() {}

    public static final Single2 getInstance() {
        return LazyHolder.s;
    }
}

饿汉式和懒汉式区别

　　从名字上来说，饿汉和懒汉，

　　饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，

　　而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

　　另外从以下两点再区分以下这两种方式：

　　1、线程安全：

　　饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，

　　懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的1、2、3，这三种实现在资源加载和性能方面有些区别。

　　2、资源加载和性能：

　　饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，

　　而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

　　至于1、2、3这三种实现又有些区别，

　　第1种，在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的，

　　第2种，在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗

　　第3种，利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗，所以一般我倾向于使用这一种。

　　什么是线程安全？

　　如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

　　或者说：一个类或者程序所提供的接口对于线程来说是原子操作，或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题，那就是线程安全的。

author@nohert