Java设计模式学习笔记二

---

[TOC]

---

Java设计模式一般分为三类：创建型、结构型、行为型

共有23种

1. 创建型模式（5个）：单例模式、抽象工厂模式、工厂模式、原型模式、建造者模式
2. 结构型模式（7个）：适配器模式、桥接模式、装饰器模式、组合模式、外观模式、享元模式、代理模式
3. 行为型模式（11个）：模板方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter模式）、状态模式、策略模式、职责链模式（责任链模式）

注：各个地方出现的名称可能略有不同（翻译问题）

单例模式

单例模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得该对象实例的方法（静态方法）。

单例模式有八种实现方法

1. 饿汉式（静态常量）
2. 饿汉式（静态代码块）
3. 懒汉式（线程不安全）
4. 懒汉式（线程安全，同步方法）
5. 懒汉式（线程安全，同步代码块）
6. 双重检查
7. 静态内部类
8. 枚举

1）饿汉式（静态常量）

• 构造器私有化（防止 new）
• 类的内部创建对象
• 向外暴露一个静态的公共方法。getInstance()
• 代码实现

class Singleton{
    //1.构造器私有化
    private Singleton(){}
    
    //2.类的内部创建对象实例
    private final static Singleton instance = new Singleton();
    
    //3.提供静态公共方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

• 优缺点：
  • 优点：简单，在类装载的时候就完成实例化。避免了线程同步的问题。
  • 缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。容易造成内存浪费（可能这个实例从始至终未曾使用过）

2）饿汉式（静态代码块）

• 代码实现

class Singleton{
    //1.构造器私有化
    private Singleton(){}
    
    //2.类的内部创建对象实例
    private static Singleton instance;
    static {
        instance = new Singleton()
    }
    
    //3.提供静态公共方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

• 优缺点：

  这种方法和上面的方法类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。所以优缺点和上面方法是一样的。

3）懒汉式（线程不安全）

• 构造器私有化
• 类的内部创建对象实例
• 提供一个静态的公共方法，当使用到该方法时，采取创建实例
• 代码实现

class Singleton{
    //1.构造器私有化
    private Singleton(){}
    
    //2.类的内部创建对象实例
    private static Singleton instance;
    
    //3.提供一个静态的公共方法，当使用到该方法时，才去创建实例（需要了才去行动叫懒汉式）
    public static Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
    
}

• 优缺点：
  • 优点：起到了 Lazy Loading 的效果，不会造成内存的浪费
  • 只能在单线程下使用，如果多线程下，一个线程进入了 if 判断语句，还未来得及往下执行，另一个线程也通过了这个 if 判断语句，这时便会产生多个实例。

4）懒汉式（线程安全，同步方法）

• 代码实现

class Singleton{
    //1.构造器私有化
    private Singleton(){}
    
    //2.类的内部创建对象实例
    private static Singleton instance;
    
    //3.提供一个静态的公共方法，加入同步处理的代码，解决线程安全问题
    public static synchronized Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

• 优缺点：
  • 优点：解决了线程安全问题
  • 缺点：效率太低，每次获取实例的时候都要进行同步操作，同步效率太低。

5）懒汉式（同步代码块）

• 代码实现

class Singleton{
    
    private Singleton(){}
    
    private static Singleton instance;
    
    public static Singleton getInstance(){
        if(instance == null) {
            synchronized (Singleton.class) {//同步代码块
                instance = new Singleton();
            }
        }
        ruturn instance;
    }
}

• 优缺点：同上（同步方法）

6）双重检查

懒汉式+同步方法+同步代码块

• 代码实现

class Singleton{
    private Singleton(){}
    
    //使用volatile关键字会强制将修改的值立即写入主存；
    private static volatile Singleton instance;
    
    public static synchronized Singleton getInstance(){//同步方法
        if(instance == null){ 
            synchronized(Singleton.class){//同步代码块
                if(instance == null){
                	instance = new Singleton();   
                }
            }
        }
        return instance;
    }
}

• 优缺点：
  • 优点：保证线程安全，延迟加载，效率较高（实例化代码只用执行一次）
  • 缺点：代码相对较复杂，需要两次 if 检查
• 推荐使用该种单例设计模式

7）静态内部类

• 代码实现

class Singleton{
    //构造器私有化
    private Singleton(){}
    
    private static volatile Singleton instance;
    
    //静态内部类，该类中有一个静态属性 Singleton
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    //提供一个静态的公共方法，直接返回 SingletonInstance.INSTANCE
    public static synchronized Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

• 优缺点：
  • 优点：保证线程安全，延迟加载，效率高
• 推荐使用

8）枚举

• 代码实现

enum Singleton{
    INSTANCE; 	//属性
}

• 优缺点：
  • 优点：线程安全，能防止反序列化重新创建新对象
• 推荐使用

单例模式在 JDK 中的应用

• JDK中，java.lang.Runtime 就是经典的单例模式（饿汉式）
  

注

• 单例模式保证了系统内存中只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
• 当实例化一个单例类的时候，必须要记住使用 相应的获取对象的方法如：getInstance()，而不是去 new
• 单例模式使用场景：需要频繁进行创建和销毁对象、创建对象时耗时过多或耗费资源过度（重量级对象），但又经常要用到的对象、工具类对象、频繁访问数据库或文件的对象（如：数据源、session工厂）