单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式为一个面向对象的应用程序提供了对象唯一的访问点，不管它实现何种功能，整个应用程序都会同享一个实例对象。

上面的概念有点抽象，简单来说，所谓单例，就是整个程序有且仅有一个实例。该类负责创建自己的对象，同时确保只有一个对象被创建。

需要注意的是：

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

懒汉式单例

当程序第一次访问单例模式实例时才进行创建。类似于延迟加载。

基本的代码如下：

 
   
   
 
  
    
    
  public class Singleton1 {
  
    
    
  

  
    
    
   private static Singleton1 singleton;
  
    
    
   private Singleton1() {
  
    
    
   }
  
    
    
  

  
    
    
   public static Singleton1 getInstance() {
  
    
    
   if(singleton==null) 
  
    
    
   {
  
    
    
   singleton=new Singleton1();
  
    
    
   }
  
    
    
   return singleton;
  
    
    
   }
  
    
    
  }

当程序需要获取该类的实例化对象的时候，调用getInstance方法，如果该类对象还没有实例化，则进行实例化，如果该类对象已经被实例化，则直接返回。

但明眼人一眼就可以看出来，这个代码存在严重的线程安全问题。没有处理线程安全问题显然是没办法使用的。

因此

懒汉式单例正确的实现方式

方法上加锁

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

这种模式的缺点是方法加锁太重了，生产环境会面临严重的效率问题。

双端检锁机制

 
   
   
 
  
    
    
  public class Singleton {
  
    
    
   private Singleton() {}
  
    
    
  

  
    
    
   private static volatile Singleton singleton;
  
    
    
  

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

对代码块加锁相对比较轻量。并且使用双端检锁机制，在保证线程安全的同时，可以尽最大化提升效率。

假设有两个线程同时到达synchronized语句块，那么实例化代码只会由其中先抢到锁的线程执行一次，而后抢到锁的线程会在第二个if判断中发现singleton不为null，所以跳过创建实例的语句。再后面的其他线程再来调用getInstance方法时，只需判断第一次的if(singleton==null)，然后会跳过整个if块，直接return实例化后的对象。

在双重检查锁模式中，给singleton这个对象加了volatile关键字，那为什么要用volatile呢？主要就在于singleton=newSingleton()，它并非是一个原子操作。

静态内部类

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

采用了静态内部类实例singleton对象，静态内部类相当于一个静态属性，只有在第一次加载类时才会初始化，在类初始化时，别的线程是无法进入的，因此既实现了线程安全，又避免了同步带来的性能影响。

饿汉式单例

顾名思义，该模式在类被加载时就会实例化一个对象。

该模式能简单快速的创建一个单例对象，而且是线程安全的(只在类加载时才会初始化，以后都不会)。但它有一个缺点，就是不管你要不要都会直接创建一个对象，会消耗一定的性能(当然很小很小，几乎可以忽略不计，所以这种模式在很多场合十分常用而且十分简单)

 
   
   
 
  
    
    
  //饿汉式单例类。在类初始化时，已经自行实例化
  
    
    
  public class Singleton1 {
  
    
    
   private Singleton1() {}
  
    
    
   private static final Singleton1 single = new Singleton1();
  
    
    
   //静态工厂方法
  
    
    
   public static Singleton1 getInstance() {
  
    
    
   return single;
  
    
    
   }
  
    
    
  }