设计模式-单例模式

单例模式实现方式：

1. 饿汉模式
   1. 特点：调用效率高，不能延时加载，线程天然安全
   2. 缺陷：不能延时加载
2. 懒汉模式
   1. 特点：调用效率低，能延时加载，同步锁实现线程安全
   2. 缺陷：调用效率低
3. 双重检测模式
   1. 特点：调用效率高，能延时加载，双重同步锁实现线程安全，
   2. 缺陷：由于JVM底层模型原因偶尔会出错
4. 枚举
   1. 特点：调用效率高，不能延时加载，线程天然安全，不会反射破解和反系列化破解
   2. 缺陷：不能延时加载
5. 静态内部类
   1. 特点：调用效率高，能延时加载，线程天然安全，推荐使用

饿汉模式：

package com.project.singleton;

import java.io.ObjectStreamException;

/**
 * 饿汉模式
 * 属性初始化，立即加载到类是(立即加载，无延时加载)，天然线程安全
 * @author Administrator
 *
 */
public class SingletonDemo1 {
	/**
	 * 属性私有化
	 */
	private static SingletonDemo1 singlet = new SingletonDemo1();

	/**
	 * 私有化构造器
	 */
	private SingletonDemo1() {
		/*如果多次创建抛出异常，防止利用反射破解单例模式*/
		if (singlet != null) {
			throw new RuntimeException();
		}
	}
	/**
	 * 提供公共接口，方法没有同步调用效率高
	 * @return
	 */
	public static SingletonDemo1 getInterface() {
		return singlet;
	}
	/**
	 * 反系列化是，如果定义了resolve则直接返回该方法指定的对象，而不需要创建
	 * @return
	 * @throws ObjectStreamException
	 */
	private Object readResolve() throws ObjectStreamException{
		return singlet;
	}
}

懒汉模式：

package com.project.singleton;

/**
 * 懒汉模式
 * 调用类的时候再初始化对象实现懒加载，天然线程安全
 * @author Administrator
 *
 */
public class SingletonDemo2 {
	/**
	 * 属性私有化
	 */
	private static SingletonDemo2 singlet;

	/**
	 * 私有化构造器
	 */
	private SingletonDemo2() {

	}
	/**
	 * 提供公共接口，设置线程锁，保证线程安全
	 * @return
	 */
	public static synchronized SingletonDemo2 getInterface() {
		if(singlet==null){
			singlet = new SingletonDemo2();
		}		
		return singlet;
	}
}

双重检测锁模式：

package com.project.singleton;

/**
 * 双重检测锁模式
 * 双重锁，只在创建对象时加锁，提高了效率，也不用每次都进行同步，
 * 但是由于编译器优化和jvm的底层内部模型的原因可能出错
 * @author Administrator
 *
 */
public class SingletonDemo3 {
	/**
	 * 属性私有化
	 */
	private static SingletonDemo3 singlet;

	/**
	 * 私有化构造器
	 */
	private SingletonDemo3() {

	}

	/**
	 * 提供公共接口，方法没有同步调用效率高
	 * ①线程1进入检测singlet是否为空。不为空直接放回已存在的singlet
	 * ②如果为空声明一个singletonDemo3对象，添加安全锁1，保证进入锁中只有一个线程
	 * ③将singletOut赋值给singlet，再次检测对象是否为空
	 * ④增加第二个安全锁，保证保证对象为空，
	 * ⑤创建初始化singletOut对象
	 * ⑤将singletonOut赋值给singlet对象
	 * 
	 * @return
	 */
	public static SingletonDemo3 getInterface() {
		if (singlet == null) {
			SingletonDemo3 singleOut;
			synchronized (SingletonDemo3.class) {
				singleOut = singlet;
				if (singleOut == null) {
					synchronized (SingletonDemo3.class) {
						if (singleOut == null) {
							singleOut = new SingletonDemo3();
						}
					}
					singlet = singleOut;
				}
			}
		}
		return singlet;
	}
}

静态内部类模式：

package com.project.singleton;

/**
 * 静态内部类
 * 实现了效率和线程双向安全.懒加载，防止反射和反系类化
 * @author Administrator
 *
 */
public class SingletonDemo5 {
	/**
	 * 私有化构造器
	 */
	private SingletonDemo5() {

	}
	/**
	 * 静态内部类，外部类创建的时候未对内部类初始化，调用时在初始化内部类，类加载过程天然线程安全
	 * @author Administrator
	 *
	 */
	private static class SingletonClassInterface{
		private static final SingletonDemo5 singlet = new SingletonDemo5() ;
	}
	/**
	 * 提供公共接口，方法没有同步调用效率高
	 * @return
	 */
	public static SingletonDemo5 getInterface() {
		return SingletonClassInterface.singlet;
	}
}

枚举对象模式：

package com.project.singleton;

/**
 * 枚举实现单例模式，
 * 实现了效率和线程，但是不能进行烂架子啊
 * @author Administrator
 *
 */
public enum SingletonDemo4 {
	/**
	 * 枚举对象天然单例
	 */
	INSIANCE;
	/*其他方法定义*/
}

防止反射破解（构造器加判断，如果多次抛异常）：

	/**
	 * 私有化构造器
	 */
	private SingletonDemo1() {
		/*如果多次创建抛出异常，防止利用反射破解单例模式*/
		if (singlet != null) {
			throw new RuntimeException();
		}
	}

防止反系列化破解：

	/**
	 * 反系列化是，如果定义了resolve则直接返回该方法指定的对象，而不需要创建
	 * @return
	 * @throws ObjectStreamException
	 */
	private Object readResolve() throws ObjectStreamException{
		return singlet;
	}