单例模式
单例模式有以下特点：
- 单例类只能有一个实例
- 单例类必须自己创建自己的唯一实例
- 单例类必须给所有其他对象提供这一实例
优点：
- 只有一个实例，可以减少内存开销
- 避免对资源的多重占用
- 设置全局资源访问
单例的几种写法：
/************手写一定要自己动手手写 面试你会发现全是手写一个单例模式开始***********/
- 懒汉式
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的时候才去初始化这个单例
- 饿汉天生是线程安全的
- 懒汉本身非线程安全 为了实现线程安全有几种写法
