[知识点] 漫谈设计模式 03

第二篇 创建对象

- 直接使用new 所带来的高耦合度。

- 如何避免耦合度？

- OOP带给我们的好处之一是封装，如果封装这些实例化的细节，即对客户对象隐藏实例化的过程，

 那么我们新添加一个接口的实现或者抽象类的具体类，也不会影响客户代码了，降低了耦合度。

- 客户对象（Client）和服务对象（Service） -->可移植性和重用性

-- Chapter 3: 单例模式【Singleton】

-> 如何保证一个类在一个系统里面只有一个实例?

-- Chapter 4: 工厂方法模式【Factory method】

-> 如何实例化对象使得对象和使用者之间的耦合度降低?

-- Chapter 5: 原型模式【Prototype】

-> 如何拷贝现有的对象快速的创建一个新的复杂对象?

-- Chapter 6: 控制反转【IoC】

-> IoC和依赖注入DI  Inverse of contrale

# 3.1 概述

- 一个系统里只有一个类

- 常见：缓存池，数据库连接池，线程池，一些应用服务实例等

- 在多线程的环境中，为了保证实例的唯一性实则不易

# 3.2 最简单的实例

- 该类的构造方法是私有的(外部类无法创建)

- 提供一个全局访问点

- [code]

public class Singleton {

private static Singleton instance = new Singleton(); //外界无法访问

private Singleton() { //客户对象无法创建

}

public static Singleton getInstance () { //全局访问点

return instance;

}

}

  [code]

注意 1. instance没有直接暴露给外界

 2. 此实现是线程安全，当多个线程同时去访问该类的getInstance方法时，不会初始化多个对象，

    因为JVM在加载此类时，对于static属性的初始化只能由一个线程执行且仅一次。

     3. 客户端使用简便： Singleton singleton = Singleton.getInstance();

# 3.3 进阶

## 3.3.1 迟延创建

- 只有在第一次使用该类的实例化时才去实例化。

->> 把单例的实例化个过程移至getInstance方法即可，而不是在加载类时预先创建。

- [code]

public class UnThreadSaftSingleton {

private UnThreadSaftSingleton instance;

public static UnThreadSaftSingleton getInstance () {

if (instance == null) {

instance = new UnThreadSaftSingleton();

}

return instance;

}

}

[code]

## 3.3.2 线程安全

注意： 1. 高并发环境中，线程不安全的，会产生多个指向该类的实例，并出现内存泄漏的情况。

2. 解决该问题，只需要对getInstance方法加 synchronized 关键字。

## 3.3.3 Double-Check Locking

- synchronized 性能有问题 --> 对整个getInstance方法进行同步是没有必要的

- 只要保证被实例化的那段逻辑被一个线程执行就OK了，而返回引用的那段代码则没必要同步

[code] 

public class DoubleCheckSingleton {

private valotile static DoubleCheckSingleton instance = null;

public static DoubleCheckSingleton getInstance () {

if(instance == null) {

synchronized(DoubleCheckSingleton.class) { //synchronize creation block

if (instance == null) {

instance = new DoubleCheckSingleton();

}

}

}

return instance;

}

}

[code]

注意： 1. 锁住初始化代码块

2. 两次判断，故称 Double checked Locking

3. 属性instance是被volatile修饰的。 作用：线程能够自动发现volatile变量的最新值

4. 此程序只有在Java 5 及以上版本才能运行

## 3.3.4 Initialization on demand holder

- 另一种实现线程安全的单例模式

[code]

public class LazyLoadedSingleton {

private LazyLoaderSingleton () {

}

private static class LazyHolder {

private static final LazyLoadedSingleton singletonInstance = 

new LazyLoadedSingleton();

}

public static LazyLoadedSingleton getInstance () {

return LazyHolder.singletonInstance;

}

}

[code]

注意：只有第一调用 getInstance 时才会加载。

## 3.3.5 Singleton的序列化

- 如果Singleton实现了Serializable接口，特别需要注意：

在默认情况下，每次反序列化总会创建一个新的实例对象，这样一个系统就会出现多个对象可供使用。

- 需要在readResolve method 里面做文章

[code]

public class SerialibleSingleton implements Serializable {

private static final long serialVersionUID = 1L;

static SerialibleSingleton instance = new SerialibleSingleton();

private SerialibleSingleton(){

}

//This method is called immediately after an object of this class deserialized.

//This method return the singleton instance.

private Object readResolve () {

return instance;

}

}

[code]

- 这样内存中始终保存一个对象

# 3.5 总结

- 基于同一个Jvm中，如何保证一个类只有一个实例

- 如果在分布式环境中，可能需要考虑如何保证在整个应用（可能分布在不同的JVM上）只有一个实例。

 

==思路清晰，简单易懂，又不失深度，好书==