Java 设计模式小解

java 的设计模式大概可以分为3类

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

下面逐一介绍每个模式的例子
1.单例模式(Singleton) 每个类只有一个实例，并且实现了全局的访问，使用场景：当某个类只需有一个实例的时候 ，一些管理器或者控制器通常被设计为单例模式。好处：可以避免重复创建对象的时间开销，节省内存空间。

饿汉模式：饿汉模式是最简单的一种单例模式，很容易发现 该模式下的构造函数是private 的，这样就不会被别人实例化
缺点：在类加载的时候就会对类进行实例化，实例在真个程序周期内都会存在，即便没人使用，也会初始化。浪费内存！
优点：只在类加载的时候创建一次，不会因为多线程和创建多次

适用场景：实例化所占内存比较小，且在类初始化的时候就会被使用
不适用场景：单例所占内存比较大，或者单例只在某个特定场景下使用

package smaug.cloud.provider.mode.singleton;

/**
 - Created by naonao on 17/11/26.
 - 饿汉模式
 */
public class Singleton1 {
    private static Singleton1 singleton1 = new Singleton1();

    private Singleton1() {
    }

    public static Singleton1 newInstance() {
        return singleton1;
    }
}

关键点

• 构造函数私有化
• 静态私有成员 – 在类加载的时候即初始化完成
• 公开访问点

2.懒汉模式

package smaug.cloud.provider.mode.singleton;

/**
 * Created by naonao on 17/11/26.
 * 懒汉模式
 */
public class Singleton2 {
    private static Singleton2 instance = null;

    private Singleton2() {
    }

    public static Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }
}

懒汉模式中的单例是在需要的时候才会去创建，如果不需要，不会创建。如果已经创建，则调用的时候不会再次创建，只会使用已经创建好的。
缺点：线程不安全，多个线程可能会并发调用创建单例创建多个实例，解决方法

public class Singleton2 {
    private static Singleton2 instance = null;

    private Singleton2() {
    }

    public static synchronized Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }
}

上面的方法看似解决了多线程并发问题， 但是 synchronized 修饰的同步方法会比一般方法慢。

3解决方法 ：双重校验锁

public class Singleton2 {
    private static Singleton2 instance = null;

    private Singleton2() {
    }

    public static synchronized Singleton2 getInstance() {
        if (instance == null) {
            synchronized (Singleton2.class){
                if (instance == null) {
                    instance = new Singleton2(); //2 
                }
            }
        }
        return instance;
    }
}

特别标注

• synchronized修饰的代码块前 有instance 的空判断， 由于单例对象只需要创建一次，后面再次调用getInstance的时候直接返回instance对象即可
• 特别注意 如果线程A B 同时执行到了 if (instance == null) { 的时候， A 和B 都会认为 没有创建实例 那么两个人都会创建实例 ，显然与我们的预期不符，那么 第二个 if (instance == null) 就可以避免创建多个对象啦

然而事实并不像我们想的那样 由于 指令重排优化的存在，导致初始化Singleton和将对象地址赋给instance字段的顺序是不确定的。在某个线程创建单例对象时，在构造方法被调用之前，就为该对象分配了内存空间并将对象的字段设置为默认值。此时就可以将分配的内存地址赋值给instance字段了，然而该对象可能还没有初始化。若紧接着另外一个线程来调用getInstance，取到的就是状态不正确的对象，程序就会出错
那么解决方法呢 volatile 禁止指令重排序

public class Singleton2 {
    private static volatile Singleton2 instance = null;

    private Singleton2() {
    }

    public static synchronized Singleton2 getInstance() {
        if (instance == null) {
            synchronized (Singleton2.class){
                if (instance == null) {
                    instance = new Singleton2(); //2
                }
            }
        }
        return instance;
    }
}

4.静态内部类

public class Singleton3 {
    private static class SingletonHolder {
        private static Singleton3 instance = new Singleton3();
    }

    private Singleton3() {

    }

    public static Singleton3 getInstacne() {
        return SingletonHolder.instance;
    }
}

特别注意

• 和饿汉模式一样，采用了类加载机制，不会存在多线程不安全的问题，同样吸取了懒汉模式，如果不使用内部类，就不会创建单例