设计模式（单例模式）

单例模式

单例模式有以下特点：

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

优点：

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

单例的几种写法：

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

懒汉式

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的时候才去初始化这个单例
饿汉天生是线程安全的
懒汉本身非线程安全为了实现线程安全有几种写法

设计模式（单例模式）

单例模式

单例的几种写法：

volatile

volatilel作用 禁止指令重排

推荐阅读更多精彩内容

volatilel作用禁止指令重排