【设计模式】单例模式

在这个RPC项目中（ https://github.com/brucewayne9064/MyRPCframework ）中，使用了单例工厂模式。

在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态。

1.单例模式

单例模式又叫做 Singleton模式，指的是一个类，在一个JVM里，只有一个实例存在。

单列模式分为：

饿汉模式（eager initialization）

私有化构造方法，在外部不能通过new得到新的实例。

静态类属性指向实例化对象。

提供一个public static的getInstance方法，外部通过该方法获得实例对象。所有的对象都是同一个。

//饿汉式单例
public class Hungry{

  	//私有化构造方法
		private Hungry(){  
      
		}
  	
  	//静态类属性指向实例化对象
		private final static Hungry HUNGRY = new Hungry(); 
  
  	//public static的getInstance方法，外部通过该方法获得实例对象
		public static Hungry getInstance(){
				return HUNGRY;
		}

}

懒汉模式（lazy initialization）

调用getInstance的时候，才会创建实例。

私有化构造方法。

一个静态类属性，用于指向一个实例化对象，但是暂时指向null。

public static 的getInstance方法，返回实例对象，第一次访问的时候，发现instance没有指向任何对象，这时实例化一个对象。

public class GiantDragon {
  
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){       
    }
  
    //准备一个类属性，用于指向一个实例化对象，但是暂时指向null
    private static GiantDragon instance;
      
    //public static 方法，返回实例对象
    public static GiantDragon getInstance(){
        //第一次访问的时候，发现instance没有指向任何对象，这时实例化一个对象
        if(null==instance){
            instance = new GiantDragon();
        }
        //返回 instance指向的对象
        return instance;
    }
      
}

2.单例模式的应用场景

饿汉式是立即加载的方式，无论是否会用到这个对象，都会加载。

如果在构造方法里写了性能消耗较大，占时较久的代码，比如建立与数据库的连接，那么就会在启动的时候感觉稍微有些卡顿。

懒汉式，是延迟加载的方式，只有使用的时候才会加载。

使用懒汉式，在启动的时候，会感觉到比饿汉式略快，因为并没有做对象的实例化。但是在第一次调用的时候，会进行实例化操作，感觉上就略慢。

看业务需求，如果业务上允许有比较充分的启动和初始化时间，就使用饿汉式，否则就使用懒汉式。

3.线程安全的单例模式

饿汉模式没有单线程问题，但是懒汉模式存在。

懒汉模式的单例如下：

public class MySingleton {
	
	private static MySingleton instance = null;
	
	private MySingleton(){}
	
	public static MySingleton getInstance() {
		if(instance == null){//懒汉式
			instance = new MySingleton();
		}
		return instance;
	}
}

在创建实例前增加准备工作如下：

public class MySingleton {
	
	private static MySingleton instance = null;
	
	private MySingleton(){}
	
	public static MySingleton getInstance() {
		try { 
			if(instance != null){//懒汉式 
				
			}else{
				//创建实例之前可能会有一些准备性的耗时工作 
				Thread.sleep(300);
				instance = new MySingleton();
			}
		} catch (InterruptedException e) { 
			e.printStackTrace();
		}
		return instance;
	}
}

多线程场景如下：

public class MyThread extends Thread{
  	
	@Override
	public void run() { 
		System.out.println(MySingleton.getInstance().hashCode());
	}
	
	public static void main(String[] args) { 
		
		MyThread[] mts = new MyThread[10];
		for(int i = 0 ; i < mts.length ; i++){
			mts[i] = new MyThread();
		}
		
		for (int j = 0; j < mts.length; j++) {
			mts[j].start();
		}
	}
}

运行结果如下：

发现并不是同一个实例，线程安全无法保证。

解决方法1：方法中声明synchronized关键字

出现非线程安全问题，是由于多个线程可以同时进入getInstance()方法，那么只需要对该方法进行synchronized的锁同步即可：

public class MySingleton {
	
	private static MySingleton instance = null;
	
	private MySingleton(){}
	
	public synchronized static MySingleton getInstance() {
		try { 
			if(instance != null){//懒汉式 
				
			}else{
				//创建实例之前可能会有一些准备性的耗时工作 
				Thread.sleep(300);
				instance = new MySingleton();
			}
		} catch (InterruptedException e) { 
			e.printStackTrace();
		}
		return instance;
	}
}

解决方法2：同步代码块

public class MySingleton {
	
	private static MySingleton instance = null;
	
	private MySingleton(){}
	
	public static MySingleton getInstance() {
		try { 
			synchronized (MySingleton.class) {
				if(instance != null){//懒汉式 
					
				}else{
					//创建实例之前可能会有一些准备性的耗时工作 
					Thread.sleep(300);
					instance = new MySingleton();
				}
			}
		} catch (InterruptedException e) { 
			e.printStackTrace();
		}
		return instance;
	}
}

以上两种方法执行效率较低

解决方法3：Double Check Locking 双检查锁机制（推荐），线程安全的同时又提高代码效率

public class MySingleton {
	
	//使用volatile关键字保其可见性
	volatile private static MySingleton instance = null;
	
	private MySingleton(){}
	 
	public static MySingleton getInstance() {
		try {  
			if(instance != null){//懒汉式 
				
			}else{
				//创建实例之前可能会有一些准备性的耗时工作 
				Thread.sleep(300);
				synchronized (MySingleton.class) {
					if(instance == null){//二次检查，如果没做二次检查还是有可能出现线程安全问题
						instance = new MySingleton();
					}
				}
			} 
		} catch (InterruptedException e) { 
			e.printStackTrace();
		}
		return instance;
	}
}

其他解决方案：使用静态内置类实现单例模式，序列化与反序列化的单例模式实现，使用static代码块实现单例，使用枚举数据类型实现单例模式，完善使用enum枚举实现单例模式

参考链接：https://blog.csdn.net/cselmu9/article/details/51366946/