温故而知新之——设计模式（三）

说完设计中的7个原则，今天我们来看看创建型模式。创建行模式到底是做什么用的呢？

创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。

创建型模式分为以下几种：

1. 单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。
2. 原型（Prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。
3. 工厂方法（FactoryMethod）模式：定义一个用于创建产品的接口，由子类决定生产什么产品。
4. 抽象工厂（AbstractFactory）模式：提供一个创建产品族的接口，其每个子类可以生产一些列相关的产品。
5. 建造者（Builder）模式：将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。

工厂方法模式属于类创建型，其他属于对象创建型。

 

磨磨唧唧的，说了这么多原则和概念。那到底这些模式都是做什么的，怎么做的，为什么要这样模式。咱们一个一个来看。

 

单例模式

 

单例模式（Singleton Pattern）是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

 

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建于销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否可以有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

应用实例：

1. 一个公司只有一个老板。
2. 使用Spring 框架，不可避免需要读取框架配置文件（.properties文件），为了避免重复读取，并保证数据的一致性、减小内存开销等原因，使用了大量的单例模式来操作配置文件。

单例模式的几种实现方式：

单例模式（Singleton Pattern）是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

 

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建于销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否可以有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

应用实例：

1. 一个公司只有一个老板。
2. 使用Spring 框架，不可避免需要读取框架配置文件（.properties文件），为了避免重复读取，并保证数据的一致性、减小内存开销等原因，使用了大量的单例模式来操作配置文件。

 

单例模式的几种实现方式：

1.懒汉式，线程不安全

是否Lazy初始化：是

是否多线程安全：否

实现难度：易

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

这种方式lazy loading很明显，不要求线程安全，在多线程不能正常工作。

 

public class Singleton { 

    private static Singleton instance; 

    private Singleton (){} 

 

    public static Singleton getInstance() { 

    if (instance == null) { 

        instance = new Singleton(); 

    } 

    return instance; 

    } 

}

2.懒汉式，线程安全

是否Lazy初始化：是

是否多线程安全：是

实现难度：易

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

优点：第一次调用才初始化，避免内存浪费。

缺点，必须加锁synchronized才能保证单例，但加锁会影响效率。

getInstance（）的性能应对应用程序不是很关系（该方法使用一般不太频繁）。

public class Singleton { 

    private static volatile Singleton instance; 

    private Singleton (){} 

    public static synchronized Singleton getInstance() { 

    if (instance == null) { 

        instance = new Singleton(); 

    } 

    return instance; 

    } 

}

3.饿汉式

是否Lazy初始化：否

是否多线程安全：是

实现难度：易

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

优点：没有加锁，执行效率会提高。

缺点：类加载时就初始化，浪费内存。

它基于classloader机制避免了多线程同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，但单例模式中大多数都是调用getInstance方法，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

public class Singleton { 

    private static Singleton instance = new Singleton(); 

    private Singleton (){} 

    public static Singleton getInstance() { 

    return instance; 

    } 

}

 

4.双检锁/双重校验锁（DCL，double-checked locking）

JDK版本：JDK1.5起

是否Lazy初始化：是

是否多线程安全：是

实现难度：较复杂

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

getInstance（）的性能对应用程序很关键。

public class Singleton { 

    private volatile static Singleton singleton; 

    private Singleton (){} 

    public static Singleton getSingleton() { 

    if (singleton == null) { 

        synchronized (Singleton.class) { 

        if (singleton == null) { 

            singleton = new Singleton(); 

        } 

        } 

    } 

    return singleton; 

    } 

}

5.登记式/静态内部类

是否Lazy初始化：是

是否多线程安全：是

实现难度：一般

描述：这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式二不是双检锁方式。这种方式只适合用于静态域的情况，双检锁方式可以在实例域需要延迟初始化时使用。

这种方式同样利用了classloader机制来保证初始化化instance时只有一个线程，它跟第3中方式不同的是：第三种方式只要Singletion类被装载了，那么instance就会被实例化（没有达到lazy loadzing效果），而这种方式是Singletion类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有通过显示调用getInstance方法时，才会显示装载SingletionHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，所以想让它延时加载，另外一方面，又不希望在Singletion类加载时就实例化，因为不能确保Singletion类还可能在其他的地方被主动使用而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式比相比第3种就显得很合理。

public class Singleton { 

    private static class SingletonHolder { 

    private static final Singleton INSTANCE = new Singleton(); 

    } 

    private Singleton (){} 

    public static final Singleton getInstance() { 

    return SingletonHolder.INSTANCE; 

    } 

}

6.枚举

JDK版本：JDK1.5起

是否Lazy初始化：否

是否多线程安全：是

实现难度：易

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

这种方式是Effective java作者Josh Bloch提倡的方式，它不仅能避免多线程同步的问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于JDK1.5之后才加入enum特性，这种方式不免让人感觉生疏，在实际工作中，也很少用。

不能通过reflection attack来调用私有构造方法。

public enum Singleton { 

    INSTANCE; 

    public void whateverMethod() { 

    } 

}

 

经验之谈：一般情况下，不建议使用第1种和第2种懒汉方式，建议使用第三种饿汉方式。只有在要明确实现lazy loading效果时，才会使用5种登记方式。如果涉及到反序列创建对象时，可以尝试使用第6种枚举方式。如果有其他特殊的需求，可以考虑使用第4种双检锁方式。

 

 

最后：

在乎面子的是弱者，给人面子的才是强者。当你越穷的时候，其实面子越不值钱，放下面子，你才有变得更强的机会。