java 单例模式

单例模式定义：

一个类只有一个对象实例，并且自行实例化自行向系统提供这个实例。

如果构造方法是用public 修饰的话，每new  一次都是创建出一个该类的对象，所以我们可以实例化很多对象。

但对于一些类我们只希望存在一个对象。

引自百度：在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。如在Windows中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要。

单例模式结构：

 

 

要点：

1.私有的构造方法

2.该类的私有静态对象

3.一个共有静态函数用于创建或获取它本身的静态私有对象

 

 

两种模式：饿汉模式和懒汉模式

单例模式之懒汉式，顾名思义就是懒，所以需要时才创建在堆中（实例化一个对象），并将该对象交给自己的引用。多线程下不能保证唯一性。

代码实现：

//单例模式之懒汉式：需要时才创建在堆中，多线程下不能保证唯一性
public class Singleton{
	//静态私有对象
	private static Singleton instance=null;
	//私有构造器
	private Singleton(){
		
	}
	//公有方法创建或获取自己本身的私有对象
	public static Singleton getInstance(){
		if(instance==null){
			instance=new Singleton();
		}
		return instance;
	}

实现线程安全的懒汉式单例方法：

1. 使用synchronized 修饰 getSingleton()方法或synchronized块。保证了对临界资源的同步互斥访问。（这种方法效率低）

2.使用双重检查

代码如下：

public class Singleton {

	// 供私有的构造函数
	private Singleton() {

	}

	// 类定义中含有一个该类的静态私有对象
//使用volatile关键字防止重排序，因为 new Singleton()是一个非原子操作，可能创建一个不完整的实例
	private static volatile Singleton instance = null;

	
	// 静态的公有的函数用于创建或获取它本身的静态私有对象
	public static Singleton getInstance() {
		if (instance == null) { //第一次检查
			synchronized (Singleton.class) {
				if (instance == null) {//第二次检查
					instance = new Singleton();
				}
			}
		}
		return instance;
	}

 

单例类被加载时，就会实例化一个对象并交给自己的引用，供系统使用。

因为instance= new Singleton（）；创建一个单例类的对象时，这不是一个原子操作。（引用百度：原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。）

这句话在JVM中做了三件事：

1.给对象instance分配内存空间

2.调用私有构造函数初始化对象

3.将对象instance指向刚分配的内存空间（执行完这一步instance就不是null了）

但这个过程可能发生指令重排序，也就是上面三步不一定是按上面的这个顺序执行的。

所以在多线程下，比如线程A中对象instance为null时，执行synchronized 语句，对这个方法加锁，然后new Singleton（），这里会发生指令重排序，就是instance执行了上面的1和3，但没有执行2，所以instance没有完成初始化工作。而此时线程B刚好执行第一次检查时，instance不再为null,就直接return instance，导致线程B可以获取到没有初始化的instance。解决这个问题的办法是加关键字volatile。

 

为什么需要二次检查？

如果有两个线程里instance 同时为null，都过了第一次检查，然后线程A加锁完后，new创建了一个实例instance。但如果不进行第二次检查，那么线程B的instance在第一次检查时为null，在线程A创建了一个实例后，它也还会创建一个实例。这样就不能保证单例了。

 

 

单例模式之饿汉式，一开始就创建，多线程下也能保证唯一性。

代码实现：

public class Singleton{
     //静态私有对象
	private static Singleton instance=new Singleton();
     //私有构造器
	private Singleton(){
		
	}
     //返回静态私有对象的共有静态方法
 	public static Singleton getInstance(){
		return instance;
	}

   那么为什么饿汉式的单例模式是线程安全的？

因为它是在类加载时完成初始化的，类加载的方式是按需加载，且只加载一次。

因此，在单例类被加载时，就会实例化一个对象并交给自己的引用，供系统使用。也就是说，在线程访问单例对象之前就已经创建好了。再加上，一个类在整个生命周期中只会被加载一次，因此该单例类只会创建一个实例。所以线程每次都只能去拿那个创建好的唯一的对象，可以说它天生就是线程安全的。

 

 

静态内部类实现单例模式

public class Singleton3 {

	// 私有构造器
	private Singleton3() {
	}

	// 静态内部类
	private static class HolderClass {
		private final static Singleton3 instance = new Singleton3();
	}

	public static Singleton3 getInstance() {
		return HolderClass.instance;
	}
	
	public static void main(String[] args) {
		Singleton3 s1, s2;
		s1 = Singleton3.getInstance();
		s2 = Singleton3.getInstance();
		System.out.println(s1 == s2);
	}

}

这种实现方式就避免了多线程的问题。

定义一个私有的内部类，在第一次用这个嵌套类时，会创建一个实例。而类型为HolderClass的类，只有在Singleton3.getInstance()中调用，由于私有的属性，他人无法使用HolderClass不调用Singleton3.getInstance()就不会创建实例。

它借助了类加载的特点，类加载只会加载一次，Singleton实例的创建过程在Java程序编译时期收集至<clinit>()方法中，该方法是同步方法，可以保证内存的可见性、JVM指令的顺序性和原子性。

 

枚举方式

枚举类型是不允许被继承，同样是线程安全且只能被实例化一次，但是枚举类型不饿能够懒加载，对Singleton主动使用，比如调用其中的静态方法则INSTANCE会立即得到实例化。 

//枚举类型本身是final的
public enum Singleton{
        INSTANCE;
        Singleton(){
       
        }
        public static void method(){
         //调用该方法则会主动使用Singleton，INSTANCE将会被实例化
         }       
        public static Singleton getInstance(){
             return INSTANCE;
         }
}