设计模式之Singleton

最近重新复习了下设计模式,发现这好像不是我所了解的设计模式。
今天把它记录下来，以便以后查阅学习。

饿汉式

package com.example.demo.pojo;

/**
 * 单例模式之饿汉式
 * 类加载到内存后,就实例化一个单例,JVM 保证线程安全。
 * 因为JVM只会加载类一次,所以随着类的加载而实例化一次。
 * 简单实用, 推荐使用！
 * 缺点：类加载时就完成实例化，不管你否需要使用。
 *
 */
public class SingletonDemo1 {
	private static final SingletonDemo1 SINGLETON = new SingletonDemo1();
	private SingletonDemo1(){

	}

	public  static SingletonDemo1 getInstance(){
		return SINGLETON;
	}


	public static void main(String[] args)  {

		for (int i = 0; i < 100; i++) {
			new Thread(()->
					System.out.println(getInstance())
			).start();
		}
	}

}

该写法可在实际当中使用，唯一的缺点就是非 lazy loading 。
饿汉式之静态内部类：

package com.example.demo.pojo;

/**
 * 饿汉式之静态内部类
 * JVM 保证单例。
 * 类加载时,不会加载内部类,这样可以实现 lazy loading (懒加载)
 *
 *
 */
public class SingletonDemo4 {

	private SingletonDemo4(){

	}
	//静态内部类
	private static class SingleHolder{
		private static final SingletonDemo4 SINGLETON = new SingletonDemo4();

		public  static SingletonDemo4 getInstance(){
			return SINGLETON;
		}
	}



	public static void main(String[] args)  {


		for (int i = 0; i < 100; i++) {
			new Thread(()->
					System.out.println(SingleHolder.getInstance())
			).start();
		}
	}

}

静态内部类算是第一种的升级版，大家不妨试试这种写法。

懒汉式

package com.example.demo.pojo;

/**
 * 单例模式之懒汉式
 *	lazy loading   懒加载
 * 缺点：不能保证单例
 * 解决方案 ：方法前面添加 synchronized 关键字 缺点：运行效率会降低
 *
 */
public class SingletonDemo2 {
	private static SingletonDemo2 SINGLETON ;
	private SingletonDemo2(){

	}

	public static synchronized  SingletonDemo2 getInstance()  {
		if(SINGLETON==null){
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			SINGLETON = new SingletonDemo2();
		}
		return SINGLETON;
	}


	public static void main(String[] args)  {
		for (int i = 0; i < 100; i++) {
			new Thread(()->
				System.out.println(getInstance())
			).start();
		}
	}

}

虽然解决了多线程的问题，但是效率会明显下降，对于有追求的程序员来说，这是不可忍受的。
懒汉式之双重检查

package com.example.demo.pojo;

/**
 * 懒汉式 之双重检查
 *	lazy loading   懒加载
 * 懒汉式升级版
 *
 *
 */
public class SingletonDemo3 {
	//添加volatile 解决指令重排发送的问题
	private static volatile SingletonDemo3 SINGLETON ;
	private SingletonDemo3(){

	}

	public static SingletonDemo3 getInstance()  {
		if(SINGLETON==null){//第一次判断如果已经实例化了,直接return.
			synchronized (SingletonDemo3.class){
				if(SINGLETON==null){//第二次判断是解决多线程问题
					try {
						Thread.sleep(1);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					SINGLETON = new SingletonDemo3();
				}

			}

		}
		return SINGLETON;
	}


	public static void main(String[] args)  {
		for (int i = 0; i < 100; i++) {
			new Thread(()->
				System.out.println(getInstance())
			).start();
		}
	}

}

以上的几种虽然说可以解决单例的问题,但是却不能防止反序列化的问题。
为此，《Effective Java》的作者 约书亚·布洛克（Joshua Bloch）。在此书中，为我们提供一种解决方案。
枚举式

package com.example.demo.pojo;

/**
 *
 * 不仅可以解决线程同步的问题,还可以防止反序列化。
 *
 */
public enum SingletonDemo5 {

	SINGLETON;

	public static void main(String[] args)  {

		for (int i = 0; i < 100; i++) {
			new Thread(()->
					System.out.println(SINGLETON.hashCode())
			).start();
		}
	}

}

最后一种，有人说是完美的，但是追求完美的程序员来说，完美，永远是下一种。
如果是实际开发中，对于普通的我们来说，还是使用第一和第二种。
好了，单例模式我们就聊到这里，本人水平有限，如有错误，还请诸位帮忙斧正。