单例模式

优点

1. 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2. 避免对资源的多重占用（比如写文件操作）

缺点

1. 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景

1. 要求生产唯一序列号
2. WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来
3. 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

注意

getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

单例模式分为6种实现方式

1、饿汉式

　　这种方式比较常用，但容易产生垃圾对象。

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

最基本的思路，就是将类的构造器私有化，那么就不能在外部调用 new 创建实例了。

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

2、懒汉式，线程不安全

　　这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。

public class Singleton {  

     // 1. 私有化构造器
    private Singleton (){}  
 // 2. 定义实例的变量
     private static Singleton instance;   
 // 3. 通过静态方法创建或返回实例
    public static Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();   // 虽然构造器是私有的，但是可以在内部调用
    }  
    return instance;  
    }  
}

3、懒汉式，线程安全

　　这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。

public class Singleton {  
    // 1. 私有化构造器
    private Singleton (){}  
    // 2. 定义实例的变量
    private static Singleton instance;  
 // 3. 通过静态方法创建或返回实例
// 通过锁，将对此方法的调用变成串行的。这就防止了错误
    public static synchronized Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  // 虽然构造器是私有的，但是可以在内部调用
    }  
    return instance;  
    }  
}

4、双重检查锁

　　这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

public class Singleton {  
   //1、私有化构造器
  private Singleton (){}  
 //定义实例的变量
    private volatile static Singleton singleton;  
  // 3. 构造一个静态方法，通过它初始化或返还对象
    public static Singleton getSingleton() {  
    if (singleton == null) {  
    // 双重检查锁机制
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}

5、静态内部类

这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。这种方法相对来说，非常优秀的一种实现。在很多地方，推荐使用这种方式。

public class Singleton {  
   //1、私有化构造器 
 private Singleton (){}  
    // 2. 充分利用了静态内部类的特性，在里面初始化 Singleton实例
    //    - 只会被初始化一次
    //    - 只有当静态内部类内部的属性、方法等被调用的时候，静态内部类才会被加载
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    
     // 3. 提供一个公共方法，获取实例化好之后的对象
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}

6、枚举（ENUM）

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。

ENUM 应该是最简单，也是最好的一种实现单例模式的方式。它充分利用了 JVM 的特性，既保证了线程安全，又保证了延迟加载。

enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    System.out.println("hello");
    }  
}
public class Main {
    public static void main (String... args) {
        Singleton theSingleton = Singleton.INSTANCE;  // 获取实例
        theSingleton.whateverMethod();            // 调用方法
    }
}    

建议：

一般情况下，不建议使用懒汉方式，建议使用饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用内部类方法。如果涉及到反序列化创建对象时，可以尝试使用枚举方式。如果有其他特殊的需求，可以考虑使用双检锁方式。