CS-Notes学习笔记-设计模式

一、单例设计模式

1.饿汉式-线程安全

线程不安全问题主要是由于 uniqueInstance 被实例化多次，采取直接实例化 uniqueInstance 的方式就不会产生线程不安全问题。
但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。

public class Singleton{
	private Singleton(){}
	private static Singleton singleton = new Singleton();
}

2.懒汉式-线程不安全

public class Singleton{
	private Singleton(){}
	private static Singleton singleton;
	public static Singleton getSingleton(){
		if (null == singleton){
			singleton = new Singleton();
		}
		return singleton;
	}
}

3.懒汉式-线程安全

直接加锁在getSingleton()方法上，会有性能问题，该方法不推荐使用。

public class Singleton{
	private Singleton(){}
	private static Singleton singleton;
	public static  synchronized Singleton getSingleton(){
		if (null == singleton){
			singleton = new Singleton();
		}
		return singleton;
	}
}

4.懒汉式-线程安全-双重枷锁

uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。

双重校验锁先判断 uniqueInstance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。

public class Singleton{
	private Singleton(){}
	private volatile static Singleton singleton;
	public static  Singleton getSingleton(){
		if (null == singleton){
			synchronized(Singleton.class){
				if(null == singleton){
					singleton = new Singleton();
				}
			}
		}
		return singleton;
	}
}

uniqueInstance 采用 volatile 关键字修饰也是很有必要的， uniqueInstance = new Singleton(); 这段代码其实是分为三步执行：
1.为 uniqueInstance 分配内存空间
2.初始化 uniqueInstance
3.将 uniqueInstance 指向分配的内存地址
但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1>3>2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

5.静态内部类

当 Singleton 类被加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 getUniqueInstance() 方法从而触发 SingletonHolder.INSTANCE 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。

这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。

public class Singleton{
	private Singleton(){}
	private static Singleton singleton;
 	private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }	
    public static  Singleton getSingleton(){
		return SingletonHolder.INSTANCE;
	}
}

6.枚举实现

该实现可以防止反射攻击。在其它实现中，通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public，然后调用构造函数从而实例化对象，如果要防止这种攻击，需要在构造函数中添加防止多次实例化的代码。该实现是由 JVM 保证只会实例化一次，因此不会出现上述的反射攻击。

该实现在多次序列化和序列化之后，不会得到多个实例。而其它实现需要使用 transient 修饰所有字段，并且实现序列化和反序列化的方法。

public enum Singleton {

    INSTANCE;

    private String objName;


    public String getObjName() {
        return objName;
    }


    public void setObjName(String objName) {
        this.objName = objName;
    }


    public static void main(String[] args) {

        // 单例测试
        Singleton firstSingleton = Singleton.INSTANCE;
        firstSingleton.setObjName("firstName");
        System.out.println(firstSingleton.getObjName());
        Singleton secondSingleton = Singleton.INSTANCE;
        secondSingleton.setObjName("secondName");
        System.out.println(firstSingleton.getObjName());
        System.out.println(secondSingleton.getObjName());

        // 反射获取实例测试
        try {
            Singleton[] enumConstants = Singleton.class.getEnumConstants();
            for (Singleton enumConstant : enumConstants) {
                System.out.println(enumConstant.getObjName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

二、简单工厂

简单工厂把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个具体子类来实例化。
这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。客户类往往有多个，如果不使用简单工厂，那么所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户类都要进行修改。

public interface Product{}
public class Product1 implements Product{}
public class Product2 implements Product{}
public class Product2 implements Product{}
public class ProductFactory{
	public Product createProduct(int type){
		if(type == 1) return new Product1();
		if(type == 2) return new Product2();
		if(type == 3) return new Product3();
	}
}

工厂方法

简单工厂的实例化在工厂中实现，工厂方法的实例化在工厂的子类中实现。

public abstract class Factory{
	public abstract Product createProduct();
}
public calss ProductFactory1 extends Factory{
	public  Product createProduct(){
		return new Product1();
	}
}
public calss ProductFactory2 extends Factory{
	public  Product createProduct(){
		return new Product2();
	}
}

行为型

责任链

空对象

方法返回null可能出现空指针问题，而且会出现代码冗余。

public abstract class AbstractOpreation{
	abstract void request();
}
public NullOperation extend AbstractOpreation{
	void request(){
		//nothing
	}
}
public RealOperation extend AbstractOperation{
	void request(){
		System.out.println("doing somthing");
	}
}

public class Client {
    public static void main(String[] args) {
        AbstractOperation abstractOperation = func(-1);
        abstractOperation.request();
    }

    public static AbstractOperation func(int para) {
        if (para < 0) {
            return new NullOperation();
        }
        return new RealOperation();
    }
}