一篇文章让你彻底理解Java的单例设计模式

下文是笔者编写的单例模式实现的八种方式，如下所示:

单例模式的简介

我们将一个类在当前进程中只有一个实例的这种模式，称之为“单例模式”
那么Java代码如何实现一个单例模式呢？下文将一一到来，如下所示:

单例模式的注意事项:
   1.单例模式在一个进程中只有一个实例
   2.单例类通常由自己创建自身的实例
   3.单例类给其他对象提供的都是同一个实例

测试代码

package com.java265.Singleton;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		System.out.println("------单例模式-----");
		
	    //创建100个线程进行测试
		
		for(int i=0;i<100;i++) {
			new Thread(()->{
				System.out.println(Single01.getInstance());
			 }).start();
		}
	}

}

单例实现模式1

饿汉式单例模式：
直接使用一个静态变量，在JVM加载类时，生成一个单例实例 如下

 
package com.java265.Singleton;

public class Single01 {	
	private static final Single01 INSTANCE = new Single01();

	private Single01() {}
	
	public static  Single01 getInstance () {
		return INSTANCE;
	}
}

使用static静态代码块生成一个单例类

package com.java265.Singleton;
public class Single02 {
	private static final Single02  INSTANCE;
	
	static {
		 INSTANCE = new Single02();
	}
	   
	private Single02() {}

	public static Single02 getInstance() {
		return INSTANCE;	
	}
	public void t() {
		 System.out.println("Single02 t方法"
		 		+ "");
	}
}

使用判断的方式，创建单例模式，
但是此处不是一个线程安全的创建方式

package com.java265.Singleton;

/*
 * 这是一个线程不安全的创建单例模式的方式
 * 这是一个懒汉式的创建单例模式的方式
 * */
public class Single03 {
	private static Single03 INSTANCE;
	private Single03() {	
	}

	public  static Single03 getInstance() {
		 if(INSTANCE ==null)
		 {
				// 多个线程都会被卡在此处，
				// 当sleep运行完毕后，多个线程会同时创建实例，此处的代码是产生线程不安全的根源
			 try
			 {
			  Thread.sleep(100);
			 }catch(InterruptedException e)
			 {
				 
			 }
			 INSTANCE = new Single03();
		 }
		 
		 return INSTANCE;
	}	
}

使用 synchronized为方法加上锁,使其线程安全

package com.java265.Singleton;
public class Single04 {
	private static volatile Single04 INSTANCE;
	private Single04() {	
	}

	/*
	 * 懒汉式生成单例实例 此处使用 synchronized 安全锁
	 */
	public  static  synchronized Single04 getInstance() {
		 if(INSTANCE ==null)
		 {
			 try
			 {
			  Thread.sleep(100);
			 }catch(InterruptedException e)
			 {
				 
			 }
			 INSTANCE = new Single04();
		 }
		 
		 return INSTANCE;
	}	
}

减少锁粒度，将synchronized关键字直接加在方法内部具体的位置上

package com.java265.Singleton;
public class Single05 {

	private static Single05 INSTANCE;
	private Single05() {
		
	}
	public  static   Single05 getInstance() {
		 if(INSTANCE ==null)
		 {
				/*
				 * 将锁直接加到方法体里面 此时出现了一个新的问题 当所有的线程都堵塞在此处，也会创建多个实例
				 */
			 synchronized(Single05.class) {
			 try
			 {
			  Thread.sleep(100);
			 }catch(InterruptedException e)
			 {
				 
			 }
			 INSTANCE = new Single05();
			 }
		 }	 
		 return INSTANCE;
	}	
}

将synchronized锁放入在方法体中，同时使用双重检查，避免创建多个实例

package com.java265.Singleton;

public class Single06 {

	private static Single06 INSTANCE;
	private Single06() {
		
	}

	public  static   Single06 getInstance() {
		 if(INSTANCE ==null)
		 {
			 synchronized(Single06.class) {
			 try
			 {
			  Thread.sleep(100);
			 }catch(InterruptedException e)
			 {
				 
			 }
			 if(INSTANCE == null)
			 {
			 INSTANCE = new Single06();
			 }
			 }
		 }
		 
		 return INSTANCE;
	}	
}

使用静态内部类的方式创建一个单例对象
此方式主要借助JVM加载类时，内部类不会被加载
当我们使用内部类的时，才会被加载，此时由JVM保证静态内部类的唯一性

package com.java265.Singleton;

/*
 * 采用内部类的方式实现一个单例模式
 * */
public class Single07 {

	private Single07() {
		
	}

	private static class Single07Holder {
		private final static Single07 INSTANCE = new Single07();
	}

	public  static   Single07 getInstance() {
		return Single07Holder.INSTANCE;
	}	
}

使用枚举创建一个静态内部类

package com.java265.Singleton;

/*
 * 采用枚举实现一个单例模式
 * */
public enum Single08 {

	INSTANCE;

	public static Single08 getInstance() {
		return INSTANCE;
	} 	
}