设计模式（单例模式）

单例模式

单例模式有以下特点：

• 单例类只能有一个实例
• 单例类必须自己创建自己的唯一实例
• 单例类必须给所有其他对象提供这一实例

优点：

• 只有一个实例，可以减少内存开销
• 避免对资源的多重占用
• 设置全局资源访问

单例的几种写法：

/************手写一定要自己动手手写 面试你会发现全是手写一个单例模式开始***********/

• 懒汉式

public class Singleton{
private static Singleton single=null;
private Singleton(){}
public static Singleton getInstance(){
if (single==null){
single=new Singleton();
}
return single;
}
}

/**
 * <pre>
 *     author : lzy
 *     e-mail : zanyang.lin@newbeeair.com
 *     time   : 2017/07/11
 *     desc   : 单例模式的几种写法
 * </pre>
 */

public class Singleton {
    private static Singleton single=null;
    private  Singleton (){}
    public static Singleton getIntstance(){
        if (single==null){
            single=new Singleton();
        }
        return single;
    }

}

这种写法没有考虑线程安全问题，在并发环境下可能出现多个singleton实例

保证线程安全修改如下

1、解决了线程同步 不过效率较低

public class Singleton {
    private static Singleton single=null;
    private  Singleton (){}
    
    //添加同步锁
    public static synchronized Singleton getIntstance(){
        if (single==null){
            single=new Singleton();
        }
        return single;
    }

}

2、在并发量不高 安全性不高情况下可以很好运行 同时避免了每次都同步的性能损耗

package com.example.singleton;

/**
 * <pre>
 *     author : lzy
 *     e-mail : zanyang.lin@newbeeair.com
 *     time   : 2017/07/11
 *     desc   : 单例模式的几种写法
 * </pre>
 */

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

    private Singleton() {
    }

    //添加同步锁
    public static  Singleton getIntstance() {
        if (single == null) {

            //双重检查锁
            synchronized (Singleton.class) {
                if (single == null) {
                    single = new Singleton();
                }
            }

        }
        return single;
    }



}

volatile

• 原子操作
  简单来说，原子操作（atomic）就是不可分割的操作，在计算机中，就是指不会因为线程调度被打断的操作。比如，简单的赋值是一个原子操作：m = 6; // 这是个原子操作
  　　假如m原先的值为0，那么对于这个操作，要么执行成功m变成了6，要么是没执行m还是0，而不会出现诸如m=3这种中间态——即使是在并发的线程中。而，声明并赋值就不是一个原子操作：int n = 6; // 这不是一个原子操作对于这个语句，至少有两个操作：①声明一个变量n②给n赋值为6——这样就会有一个中间状态：变量n已经被声明了但是还没有被赋值的状态。——这样，在多线程中，由于线程执行顺序的不确定性，如果两个线程都使用m，就可能会导致不稳定的结果出现。
• 指令重排
  简单来说，就是计算机为了提高执行效率，会做的一些优化，在不影响最终结果的情况下，可能会对一些语句的执行顺序进行调整。比如，这一段代码：

int a ;   // 语句1 
a = 8 ;   // 语句2
int b = 9 ;     // 语句3
int c = a + b ; // 语句4

正常来说，对于顺序结构，执行的顺序是自上到下，也即1234。但是，由于指令重排
的原因，因为不影响最终的结果，所以，实际执行的顺序可能会变成3124或者1324。由于语句3和4没有原子性的问题，语句3和语句4也可能会拆分成原子操作，再重排。——也就是说，对于非原子性的操作，在不影响最终结果的情况下，其拆分成的原子操作可能会被重新排列执行顺序。
　　OK，了解了原子操作和指令重排的概念之后，我们再继续看双重校验锁方式单例模式代码的问题。下面这段话直接从陈皓的文章(深入浅出单实例SINGLETON设计模式)中复制而来：主要在于singleton = new Singleton()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情：
1). 给 singleton 分配内存
2). 调用 Singleton 的构造函数来初始化成员变量，形成实例
3). 将singleton对象指向分配的内存空间（执行完这步 singleton才是非 null 了）但是在 JVM 的即时编译器中存在指令重排序的优化。
　　也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。
　　再稍微解释一下，就是说，由于有一个『instance已经不为null但是仍没有完成初始化』的中间状态，而这个时候，如果有其他线程刚好运行到第一层if (instance == null)这里，这里读取到的instance已经不为null了，所以就直接把这个中间状态的instance拿去用了，就会产生问题。这里的关键在于——线程T1对instance的写操作没有完成，线程T2就执行了读操作。

volatilel作用 禁止指令重排

volatile关键字的一个作用是禁止指令重排，把instance声明为volatile之后，对它的写操作就会有一个内存屏障（什么是内存屏障？），这样，在它的赋值完成之前，就不用会调用读操作。
　　注意：volatile阻止的不singleton = new Singleton()这句话内部[1-2-3]的指令重排，而是保证了在一个写操作（[1-2-3]）完成之前，不会调用读操作（if (instance == null)）。

3、静态内部类 延迟加载，线程安全 减少内存消耗

public class Singleton {
    
    private static class Holder{
        private static final Singleton instance=new Singleton();
    }
    private Singleton(){}
    public static final Singleton getInstance(){
        return Holder.instance;
    }

}

• 饿汉式

public class Singleton{
private static final Singleton single=new Singleton();
private Singleton(){}
public static Singleton getIntstance(){
return single;

}

}

两者区别：

• 饿汉式是类一旦加载就把单例初始化完成 保证getinstance的时候 是已经存在的
• 懒汉只有当调用getInstance的时候才去初始化这个单例
• 饿汉天生是线程安全的
• 懒汉本身非线程安全 为了实现线程安全有几种写法