单例模式 分析 代码优化

　　单例模式是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();
        });
    }
}