设计模式——单例模式

1、设计模式的定义：设计过程中可以反复使用的、可以解决特定问题的通用设计方法。
2、设计模式的目的：为了可重用代码、让代码更容易被他人理解。
3、单例模式定义 ：确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
4、主要解决：一个全局使用的类频繁地创建与销毁。
5、何时使用：当您想控制实例数目，节省系统资源的时候。
6、 如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建（针对于懒汉模式）。
7、代码实现单例模式根据实例化对象时机的不同分为两种：一种是饿汉式单例，一种是懒汉式单例。饿汉式单例在单例类被加载时候，就实例化一个对象交给自己的引用；而懒汉式在调用取得实例方法的时候才会实例化对象。
8、优点： 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。 2、避免对资源的多重占用（比如写文件操作）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

9、使用场景：

• 需要频繁实例化然后销毁的对象。

• 创建对象时耗时过多或者耗资源过多，但又经常用到的对象。

• 有状态的工具类对象。

• 频繁访问数据库或文件的对象。

• 以及其他我没用过的所有要求只有一个对象的场景。

10、注意事项：
getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化（针对懒汉模式）。

饿汉式单例

public class Singleton {
private static Singleton singleton = new Singleton();
private Singleton(){
}
public static Singleton getInstance(){
return singleton;
}
}

优点：没有加锁，执行效率会提高。缺点：类加载时就初始化，浪费内存。

懒汉式单例（线程不安全）

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

懒汉式单例（线程安全）

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

优点：第一次调用才初始化，避免内存浪费。缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。

双检锁/双重校验锁

public class Singleton {    
private static volatile Singleton singleton;   
 private Singleton() {   
  }   
   public static Singleton getInstance() {     
      if (singleton == null) {          
        synchronized (Singleton.class) {        
              if (singleton == null) {           
           singleton = new Singleton();       
          }       
         }      
       }       
        return singleton; 
             }
           }

分析：这句代码 singleton = new Singleton();拆分3个步骤：
1 .分配内存空间
2. new Singleton() 初始化
3. 对象内存引用赋值给singleton
不加volatile的情况下：
第2步和第3步可能会被重排序执行序列 1-3-2
多线程访问情况：
线程1：执行顺序 1-3-2
线程2：如果线程1执行到 3，这个时候线程2会在第一次检查是否为空时候发现对象不为空，返回一个没有正确初始化的对象并使用 ，从而导致系统异常
加上volatile：volatile 修饰的变量会在写的前后加上内存屏障，禁止指令重排序 ，所以执行顺序就只会是1-2-3，
线程2 发现singleton 不为空的时候一定是一个初始化成功的对象，从而保证系统正常

指令重排序：CPU在执行一批指令时，为了连续性和资源利用会对指令进行重排序，Java中会保证单线程执行结果是不能被改变的内存屏障 : Java为了防止cpu指令的重排序会在指定的指令前后加上内存屏障，是由Java内存模型定义的

（细看）但是这个过程
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
这个Singleton对象的实例化过程被 synchronized 锁住，无论是否出现指令从排序它返回的都是一个完整的Singleton对象，所以说volatile在这块是禁止从排序简直就是放屁，再说volatile是jdk1.5才出来的，意思是整个双检锁模式在1.5之前都一直有指令从排序的问题吗？肯定不是

其实volatile的作用是内存可见性，但是synchronized也有内存可见性，只是synchronized的修饰的线程仍然可以缓存线程副本，而volatile修饰的线程不可以，它必需从主存中获取对象状态

看这一句代码
if (singleton == null) {
synchronized (Singleton.class) {
当瞬间进入100个线程，只有一个进入锁，其他99个都在不断的获得锁，假如没有volatile，这99都已经从主存获得此时volatile是空，当第一个进入锁的线程创建并获得了Singleton对象，主存会立马将Singleton对象置为非空，但是那99个线程他们不知道啊，他们用的还是自己副本缓存Singleton对象为空的状态，他们会接着一个一个的获得锁进入锁，直至全部获得

此时引入volatile就不一样了，这99个是不能有自己的副本缓存，他们必须每次从主存中获取最新Singleton对象的状态，一旦第一个线程创建并获取了Singleton对象，其他线程会立即得知，他们就不需要获取锁了，直接拿就ok了。
这里只有99个，想想万一是十万，一千万，没有volatile给他们通知，等他们一个一个通过获取锁来获得Singleton对象，早已物是人非……

静态内部类

public class Singleton {  
  private Singleton() {  
    }  
  private static class SingletonHolder {// 静态内部类        private static Singleton singleton = new Singleton();    
  }    
  public static Singleton getInstance() {       
   return SingletonHolder.singleton;    
   }
   }

SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类（懒加载）

防止反射和反序列化

public class Singleton implements Serializable{    
private static Singleton singleton;        
private Singleton() {        
//防止反射获取多个对象的漏洞       
//反射就是通过它的Class对象来调用构造器创建出新的对象      //我们只需要在构造器中手动抛出异常，导致程序停止就可以达到目的了        
if (null != instance) {            
throw new RuntimeException();        
}    
}
public static synchronized Singleton getInstance(){
if(singleton==null){
singleton = new Singleton();
}return singleton;
}    
// 防止反序列化获取多个对象的漏洞。    
// 当从I/O流中读取对象时，readResolve()方法都会被调用到。   
 // 实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象。    
 private Object readResolve() throws ObjectStreamException {          
 return singleton;   
  }
  }

CAS实现单例模式
/* * CAS是项乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，

• 只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，
• 而是被告知这次竞争中失败，并可以再次尝试。 *
• 优点：不需要使用传统的锁机制来保证线程安全,CAS是一种基于忙等待的算法,
• 依赖底层硬件的实现,相对于锁它没有线程切换和阻塞的额外消耗,可以支持较大的并行度。
• 缺点：如果忙等待一直执行不成功(一直在死循环中),会对CPU造成较大的执行开销。 */

import java.util.concurrent.atomic.AtomicReference;
//CAS(AtomicReference)原子引用
public class Singleton {    
private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>();    
 private Singleton() {
 }     
 public static Singleton getInstance() {       
  for (;;) {            
  Singleton singleton = INSTANCE.get();           
   if (null != singleton) {               
    return singleton;         
       }          
          singleton = new Singleton();         
           if (INSTANCE.compareAndSet(null, singleton)) {              //如果当前值为空，就更新为指定的singleton对象                 return singleton;          
             }       
         }   
      }
   }

枚举模式
一个可以直接避免反射，序列化攻击的实现单例模式的方式

public enum Singleton {
singleton;public void hello() {    
  System.out.print("hello");
  }
  }