设计模式-单例模式

[size=large][color=red]单例模式[/color][/size]
[size=medium][b]需求：[/b][/size]通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

[size=medium][color=green]实现单例的四种方法：[/color][/size]

[b][size=medium]1、饿汉式---类加载的时候就创建实例[/size] [/b]代码如下：

package test.patterns.singleton;

public class Singleton {
	//类加载就初始化
	public static Singleton singleton = new Singleton();
	private Singleton(){}
	public static Singleton getInstance() {
		return singleton;
	}

	//反射攻击，出现两个实例
	public static void main(String[] args) {
		Singleton s1=Singleton.getInstance();
		Singleton s2=null;
		try {       
s2=(Singleton)Class.forName("test.patterns.singleton.Singleton").newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(s1==s2);//false
	}
}

[color=green]特点：可以通过反射机制攻击（见main函数中的例子）；线程安全[多个类加载器除外][/color]

[size=medium][b]2、懒汉式---要的时候再创建 [/b][/size]代码如下：

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

[color=green]特点：延时加载；线程安全；效率比较低，因为需要线程同步的时候比较少。[/color]

[b][size=medium]3、静态内部类 [/size][/b]代码如下：

public class Singleton3 {
	private static class SingletonHolder {
		private static Singleton3 singleton = new Singleton3();
	}
	private Singleton3(){}
	private static Singleton3 getInstance() {
		return SingletonHolder.singleton;
	}
}

[color=green]特点：线程安全；延迟加载。[/color]

[size=medium][b]4、枚举类型 [/b][/size]代码如下：

package test.patterns.singleton;
public enum Singleton4 {
	singleton4; //定义一个枚举的元素，代表一个实例
	private Singleton4() {}
	public void test() {
		System.out.println("Test~~~");
	}
	public static void main(String[] args) {
		Singleton4 s1 = Singleton4.singleton4;
		Singleton4 s2 = Singleton4.singleton4;
		s1.test();
		System.out.println(s1==s2);
	}
}

[color=green]特点：无偿提供序列化机制，绝对防止多次实例化，即使在面对复杂的序列化或者反射攻击的时候。[/color]

[b]总结分析：饿汉，懒汉，静态内部类，枚举[/b]
饿汉：因为加载类的时候就创建实例，所以线程安全(多个ClassLoader存在时例外)。缺点是不能延时加载。
懒汉：需要加锁才能实现多线程同步，但是效率会降低。优点是延时加载。
静态内部类：延迟加载，避免了静态field在单例类加载时即进入到堆内存的permanent代而永远得不到回收的缺点(大多数垃圾回收算法是这样)。
枚举：不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，没有延迟加载。

以上通过网络总结，并非原创，出现摘抄敬请谅解！Have a nice day~ :arrow: