单例模式

定义：确保某一个类只有一个实例，并且自行实例化并向整个系统提供这个实例。

饿汉式单例

public class A{
    // 声明类的实例,使用private static 修饰
    private static final A a= new A();
    // 将构造方法私有化，不需外部直接创建对象
    private A(){};
    // 提供一个外部获取实例的方法，使用public static 修饰
    public static A getInstance(){
        return a;
    }
    
}

 懒汉式单例

public class B {
    // 声明类的唯一实例,使用private static 修饰
    private static B b = null;
    // 将构造方法私有化，不需外部直接创建对象
    private B(){};
    // 提供一个外部获取实例的方法，使用public static 修饰
    public static B getInstance(){    
        if (b == null) {
            b = new B(); 
        }            
        return b;
    }
    
}

注：在懒汉模式的第9行----》如果线程A执行到此行，但还没有获取到对象，这时第二个线程B也在执行，执行到（b == null）判断，那么线程B获得的条件为真，于是继续运行下去，这样线程A和B各自获得了一个对象，在内存中就会出现两个对象！

解决线程安全的方法很多，可以在getInstance方法前加synchronized关键字，也可以在getInstance方法内增加synchronized来实现，但都不是最优秀的单例模式，建议使用“饿汉式单例”！

懒汉式单例（加入synchronized）

public class B {

    private static B b = null;
    
    private B(){};
    
    public static synchronized B getInstance(){
        if (b == null) {
            b = new B();
　　　　　}
        return b;
    }
    
}

我们对比一下懒汉模式和饿汉模式的优缺点：

1、饿汉模式的特点：加载类时比较慢，获取实例时比较快，线性安全

2、懒汉模式的特点：加载类时比较快，获取实例时比较慢，线程不安全

这两种模式对于初始化较快，占用资源少的轻量级对象来 说，没有多大的性能差异，选择懒汉式还是饿汉式都没有问题。但是对于初始化慢，占用资源多的重量级对象来说，就会有比较明显的差别了。所以，对重量级对象 应用饿汉模式，类加载时速度慢，但运行时速度快；懒汉模式则与之相反，类加载时速度快，但运行时第一次获得对象的速度慢。

从用户体验的角度来说，我们应该首选饿汉模式。我们愿意等待某个程序花较长的时间初始化，却不喜欢在程序运行时等待太久，给人一种反应迟钝的感觉，所以对于有重量级对象参与的单例模式，我们推荐使用饿汉模式。

而 对于初始化较快的轻量级对象来说，选用哪种方法都可以。如果一个应用中使用了大量单例模式，我们就应该权衡两种方法了。轻量级对象的单例采用懒汉模式，减 轻加载时的负担，缩短加载时间，提高加载效率；同时由于是轻量级对象，把这些对象的创建放在使用时进行，实际就是把创建单例对象所消耗的时间分摊到整个应 用中去了，对于整个应用的运行效率没有太大影响。

 什么情况下使用单例模式

单例模式也是一种比较常见的设计模式，它到底能带给我们什么好处呢？其实无非是三个方面的作用：

第一、控制资源的使用，通过线程同步来控制资源的并发访问；

第二、控制实例产生的数量，达到节约资源的目的。

第三、作为通信媒介使用，也就是数据共享，它可以在不建立直接关联的条件下，让多个不相关的两个线程或者进程之间实现通信。

比 如，数据库连接池的设计一般采用单例模式，数据库连接是一种数据库资源。软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损 耗，这种效率上的损耗还是非常昂贵的。当然，使用数据库连接池还有很多其它的好处，可以屏蔽不同数据数据库之间的差异，实现系统对数据库的低度耦合，也可 以被多个系统同时使用，具有高可复用性，还能方便对数据库连接的管理等等。数据库连接池属于重量级资源，一个应用中只需要保留一份即可，既节省了资源又方 便管理。所以数据库连接池采用单例模式进行设计会是一个非常好的选择。

在我们日常使用的在Windows中也有不少单例模式设计的组件，象常用的文件管理器。由于Windows操作系统是一个典型的多进程多线程系统，那么在创建或者删除某个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象。采用单例模式设计的文件管理器就可以完美的解决这个问题，所有的文件操作都必须通过唯一的实例进行，这样就不会产生混乱的现象。

再比如，每台计算机可以有若干个打印机，如果每一个进程或者线程都独立地使用打印机资源的话，那么我们打印出来的结果就有可能既包含这个打印任务的一部分，又包含另外一个打印任务的一部分。所以，大多数的操作系统最终为打印任务设计了一个单例模式的假脱机服务Printer Spooler，所有的打印任务都需要通过假脱机服务进行。

实际上，配置信息类、管理类、控制类、门面类、代理类通常被设计为单例类。像Java的Struts、Spring框架，.Net的Spring.Net框架，以及Php的Zend框架都大量使用了单例模式。

有上限多例：方便系统扩展，修正单例可能存在的性能问题，提供系统响应速度

public class C {

    /**
     * 上限数量
     */
    private static final int MAX = 2;
    
    /**
     * C对象的“名字”list
     */
    private static List<String> names = new ArrayList<String>();
    
    /**
     * C对象list
     */
    private static List<C> models = new ArrayList<C>();
    
    /**
     * 当前序列号
     */
    private static int curNum = 0;
    
    
    static {
        for (int i = 0; i < MAX; i++) {
            models.add(new C("C对象" + i));
        }
    }
    
    private C() {
    }

    /**
     * 建立一个带"名字"的C对象
     * @param name
     */
    private C(String name){
        names.add(name);
    }
    
    public static C getInstance(){
        Random random = new Random();
        
        curNum = random.nextInt(MAX);
        
        return models.get(curNum);
    }
    
    public void say(){
        System.out.println(names.get(curNum));
    }
    
}

public class Main {

    public static void main(String[] args) {
        int max = 5;
        for (int i = 0; i < max; i++) {
            System.out.print("第" + i + "个C对象：");
            C.getInstance().say();
        }
    }
    
}