单例模式 分析 代码优化

　　单例模式是23种设计模式之一，是比较简单的一种设计模式，它的目的是不管调用多少次，都返回同一个对象，它的特色是构造器私有化。

　　它分为两种结构，一种是懒汉式的，一种是饿汉式的，它们各有优缺点，咱们先从饿汉式看起，代码以下：

public class Single {
    private static Single single = new Single();

    private Single() {

    }

    public Single getInstance() {
        return single;
    }

}

　　经过上面的程序能够看出来虽然咱们加载同一个对象的目的确实达到了，但当程序被加载的时候就会建立single这个对象，当这个类有多个这样的方法时，咱们可能会用不到这个对象中大多数单例，就会形成对内存的浪费。因此就出现了懒汉式的单例模式，代码以下：

public class Single {
    private static Single single = null;

    private Single() {

    }

    public Single getInstance() {
        if(single==null){
            single = new Single();
        }
        return single;
    }

}

　　这样，只有当咱们真正调用这个对象时它才会被new出来，可是这样是存在问题的。

　　当上面的第二段代码在第一次加载的时候有两个线程对其进行了调用，则会产生两个不一样的对象，因此是线程不安全的，这时候就会想到给这个方法加个锁，加锁以后的代码以下：

public class Single {
    private static Single single = null;

    private Single() {

    }

    public synchronized Single getInstance() {
        if (single == null) {
            single = new Single();
        }
        return single;
    }

}

　　这样作确实作到了线程安全，可是当加锁这个方花费的时间会很长，升级后的代码以下：

public class Single {
    priate static Single single = null;

    private Single() {

    }

    public Single getInstance() {
        if (single == null) {
            synchronized (Single.class) {
                single = new Single();
            }
        }
        return single;
    }
}

　　仔细观察之后发现这样并无锁住，当第一次同时有两个线程到达getInstance()方法if判断时，其中有一个确定是阻塞的，当另一个执行完之后，阻塞这个线程是不会再判断是否为空的，仍是会建立一个对象的，这样又有多个对象被产生了，再对其进行升级，获得的代码以下：

public class Single {
    private static Single single = null;

    private Single() {

    }

    public Single getInstance() {
        if (single == null) {
            synchronized (Single.class) {
                if (single == null) {
                    single = new Single();
                }
            }
        }
        return single;
    }
}

　　这样就不会产生上面的问题，并且也只锁一次，由于第二次再执行这个方法时，会跳过if判断，直接返回single，不会再被锁，执行效率也会很高。

　　但即便是这样，也仍是有问题的，由于咱们不能肯定在内存中是先给对象赋值，仍是先建立了这个对象，因此第二个程序有可能获得的是初始化一半了的对象，在jdk1.5以后，咱们能够用volatile这个关键字来避免这种状况，

volatile能保证多线程之间的可见性（操做的是主内存，非线程内存），有效性(java不对其进行重排序),不能保证原子性(当读出这个变量，还未写回主内存时，别的线程读取这个变量，取的是未改变以前的值)

下面的代码加volatile关键字保证写后能够到主内存中,不加volatile可能会第一个线程将获得的值放在线程内存中，没有回写到主内存，第二个线程就没法获取到第一个线程的结果，再new一个

代码以下：

public class Single {
    private static volatile Single single = null;

    private Single() {

    }

    public Single getInstance() {
        if (single == null) {
            synchronized (Single.class) {
                if (single == null) {
                    single = new Single();
                }
            }
        }
        return single;
    }
}

　　可是这种状况不多使用，我在这里只是为了学习一下

最近有了一个新的写法：以下

public class TestSingleton {

    private static class inner{
        private static TestSingleton singleton = new TestSingleton();
    }

    private TestSingleton(){

    }
     public static TestSingleton getSingle(){
         return inner.singleton;
     }

}

这种方法很不错的，这样避免了在加载类的时候就初始化，达到了懒加载的目的

比下面这种方式好一些

public class TestSingle2 {
    
    private static TestSingle2 testSingleton ;
    
    static {
        testSingleton = new TestSingle2();
    }
    
    private TestSingle2(){
        
    }
    
    public static TestSingle2 getSingleton(){
        return  testSingleton;
    }
}

这种方式就没有实现懒加载，

另一种就是使用玫举的特性生成单例（玫举是线程安全的，final的，构造方法是private且只调一次），代码以下： 

public class SingletonEnumTest {

    private SingletonEnumTest(){

    }

    private enum Singleton{
        INSTANCE;

        private SingletonEnumTest instance;

        private Singleton(){
            instance = new SingletonEnumTest();
        }

        public SingletonEnumTest getInstance(){
            return instance;
        }
    }

    public static SingletonEnumTest getInstance(){
        return Singleton.INSTANCE.getInstance();
    }

    public static void main(String[] args) {
        IntStream.range(0,100).forEach(i->{
            new Thread(()->{
                System.out.println(SingletonEnumTest.getInstance());
            }).start();
        });
    }
}