单例设计模式

单例核心作用保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

单例模式的优点：

由于只生成一个实例，减少了系统性能的开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时

则可以在应用启动时直接产生一个单例对象，然后永久的驻留内存的方式来解决。

常见的应用场景：

1.windows的Task manager（任务管理器）就是很典型的单例模式。

2.windows的Recycle Bin（回收站)也是典型的单例应用，在整个系统运行过程中，回收站一直维护着仅有的一个实例。

3.项目中读取配置文件的类，一般也只有一个对象，没有必要每次使用配置文件中的数据，每次new一个对象读取。

4.网站的计数器，一般也采用单例模式实现，否则难以同步。

5.应用程序的日志应用，一般都是单例模式实现，一般是由于共享的日志文件一直出于打开的状态，因为只能有一个实例去操作

6.数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。

7.操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。

8.Application也是单例的典型应用（Servlet）

9.在spring中，每个bean默认是单例的，这样做的优点是Spring容器可以管理。

10.在Servlet变成中，每个Servlet也是单例。

11.springmvc/struts1中，控制器对象也是单例。

饿汉式：

package com.gcxzflgl.singleton;

public class SingletonDemo1 {
	
	//类初始化时，立即加载这个对象（没有延时加载的优势）。加载类时，天然的是线程安全的！
	private static SingletonDemo1 instance = new SingletonDemo1();  
	
	private SingletonDemo1(){
	}
	
	//方法没有同步，调用效率高！
	public static SingletonDemo1  getInstance(){
		return instance;
	}
	
}

懒汉式：

package com.gcxzflgl.singleton;


public class SingletonDemo2 {
	
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo2 instance;  
	
	private SingletonDemo2(){ //私有化构造器
	}
	
	//方法同步，调用效率低！
	public static  synchronized SingletonDemo2  getInstance(){
		if(instance==null){
			instance = new SingletonDemo2();
		}
		return instance;
	}
	
}

双重检查锁：

package com.gcxzflgl.singleton;


public class SingletonDemo3 { 

  private static SingletonDemo3 instance = null; 

  public static SingletonDemo3 getInstance() { 
    if (instance == null) { 
      SingletonDemo3 sc; 
      synchronized (SingletonDemo3.class) { 
        sc = instance; 
        if (sc == null) { 
          synchronized (SingletonDemo3.class) { 
            if(sc == null) { 
              sc = new SingletonDemo3(); 
            } 
          } 
          instance = sc; 
        } 
      } 
    } 
    return instance; 
  } 

  private SingletonDemo3() { 

  } 
    
}

静态内部类：

package com.gcxzflgl.singleton;

public class SingletonDemo4 {
	
	private static class SingletonClassInstance {
		private static final SingletonDemo4 instance = new SingletonDemo4();
	}
	
	private SingletonDemo4(){
	}
	
	//方法没有同步，调用效率高！
	public static SingletonDemo4  getInstance(){
		return SingletonClassInstance.instance;
	}
	
}

枚举：

package com.gcxzflgl.singleton;

public enum SingletonDemo5 {
	
	//这个枚举元素，本身就是单例对象！
	INSTANCE;
	
	//添加自己需要的操作！
	public void singletonOperation(){
	}
	
	
}

这里有一个问题，处了Enum的单例，其他的单例情况经过反射和反序列化后就不再是一个单例

先解决反射的问题

比如拿懒汉式来说：

package com.gcxzflgl.singleton;

import java.io.Serializable;

public class SingletonDemo6 implements Serializable {
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo6 instance;  
	
	private SingletonDemo6(){ //私有化构造器
		
	}
	
	//方法同步，调用效率低！
	public static  synchronized SingletonDemo6  getInstance(){
		if(instance==null){
			instance = new SingletonDemo6();
		}
		return instance;
	}

}

package com.gcxzflgl.singleton;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;

public class Client2 {
	
	public static void main(String[] args) throws Exception {
		SingletonDemo6 s1 = SingletonDemo6.getInstance();
		SingletonDemo6 s2 = SingletonDemo6.getInstance();
		
		System.out.println(s1);
		System.out.println(s2);
		
		//通过反射的方式直接调用私有构造器
		Class<SingletonDemo6> clazz = (Class<SingletonDemo6>) Class.forName("com.gcxzflgl.singleton.SingletonDemo6");
		Constructor<SingletonDemo6> c = clazz.getDeclaredConstructor(null);
		c.setAccessible(true);
		SingletonDemo6  s3 = c.newInstance();
		SingletonDemo6  s4 = c.newInstance();
		System.out.println(s3);
		System.out.println(s4);
	}
}

输出的结果可以看到并不是单例了

解决办法：在构造器中判断当前实例是否为空改造后的Singleton6如下

package com.gcxzflgl.singleton;

import java.io.Serializable;

public class SingletonDemo6 implements Serializable {
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo6 instance;  
	
	private SingletonDemo6(){ //私有化构造器
		if(instance!=null){
			throw new RuntimeException();
		}
	}
	//方法同步，调用效率低！
	public static  synchronized SingletonDemo6  getInstance(){
		if(instance==null){
			instance = new SingletonDemo6();
		}
		return instance;
	}
}

因为我增加了判断条件只要实例不为空抛出运行时异常

再来看看反序列化的问题：

package com.gcxzflgl.singleton;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;

public class Client2 {
	
	public static void main(String[] args) throws Exception {
		SingletonDemo6 s1 = SingletonDemo6.getInstance();
		SingletonDemo6 s2 = SingletonDemo6.getInstance();
		
		System.out.println(s1);
		System.out.println(s2);
		
		//通过反序列化的方式构造多个对象 
		FileOutputStream fos = new FileOutputStream("d:/a.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(s1);
		oos.close();
		fos.close();
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
		SingletonDemo6 s3 =  (SingletonDemo6) ois.readObject();
		System.out.println(s3);
		
	}
}

运行后发现也不是单例了

解决办法：反序列化时如果定义readresolve方法，则直接返回此方法指定的对象，无需单独创建新对象。

package com.gcxzflgl.singleton;

import java.io.ObjectStreamException;
import java.io.Serializable;

public class SingletonDemo6 implements Serializable {
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo6 instance;  
	
	private SingletonDemo6(){ //私有化构造器
		if(instance!=null){
			throw new RuntimeException();
		}
	}
	
	//方法同步，调用效率低！
	public static  synchronized SingletonDemo6  getInstance(){
		if(instance==null){
			instance = new SingletonDemo6();
		}
		return instance;
	}
	
	//反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！
	private Object readResolve() throws ObjectStreamException {
		return instance;
	}
	
}

再次运行后确实是属于同一个对象了

五种单例模式的对比以及效率问题：

饿汉式：线程安全，效率高，不能延迟加载。

懒汉式：线程安全，效率不高，可以延迟加载。

双重检查锁：由于jvm底层内部模型原因，偶尔会出问题，不建议使用。

静态内部类：线程安全，效率高，可以延迟加载。

枚举:线程安全，效率高，不能延迟加载。

效率比较：

package com.gcxzflgl.singleton;

import java.util.concurrent.CountDownLatch;

public class Client3 {
	
	public static void main(String[] args) throws Exception {
		
		long start = System.currentTimeMillis();
		int threadNum = 10;
		final CountDownLatch  countDownLatch = new CountDownLatch(threadNum);
		
		for(int i=0;i<threadNum;i++){
			new Thread(new Runnable() {
				@Override
				public void run() {
					
					for(int i=0;i<1000000;i++){
						Object o = SingletonDemo1.getInstance();
					}
					countDownLatch.countDown();
				}
			}).start();
		}
		
		countDownLatch.await();	//main线程阻塞，直到计数器变为0，才会继续往下执行！
		
		long end = System.currentTimeMillis();
		System.out.println("总耗时："+(end-start));
	}
}

在开发中如何选择他们：

单例对象占用资源少，不需要延迟加载：枚举式好于饿汉式。

单例对象占用资源大，需要延迟加载：静态内部类式好于懒汉式。