1 public class Single01 { 2 /** 3 * 饿汉式 直接创建实例对象，不管是否需要这个对象 4 * 5 * 6 * 1.构造器私有化 7 * 2.自行创建，并且用静态变量保存 8 * 3.向外提供这个实例 9 * 4、强调这是一个单例，我们可以用final修饰 10 */ 11 public static final Single01 instance = new Single01(); 12 private Single01() { 13 } 14 } 15 16 public enum Single02 { 17 /** 18 * 枚举类型，表示该类型的对象是有限的几个 19 * 我们可以限定为一个，就成了单例 20 * 21 */ 22 INSTANCE 23 } 24 25 26 public class Single03 { 27 /** 28 * 静态代码块 饿汉式 29 * 通常用来传递参数 复杂方式的应用 30 */ 31 public static final Single03 INSTANCE; 32 // private String info; 33 static { 34 INSTANCE = new Single03(info); 35 } 36 private Single03(String info){ 37 } 38 }
上述代码是饿汉式的实现方式：直接创建对象，不存在线程安全问题。
1 //初始懒汉模式，存在线程安全问题 2 public class Single04 { 3 /** 4 * 懒汉式 延迟创建实例对象 5 * 6 * 1、构造器私有化 7 * 2.用一个静态变量保存这个唯一的实例 8 * 3、提供一个静态方法，获取这个实例对象 9 */ 10 private static Single04 instance; 11 private Single04(){ 12 } 13 public static Single04 getInstance(){ 14 if(instance == null) { 15 instance = new Single04(); 16 } 17 return instance; 18 } 19 } 20 21 22 public class Single05 { 23 /** 24 * 双检锁方式实现线程安全 效率最优 25 * 懒汉式 延迟创建实例对象 26 * 27 * 1、构造器私有化 28 * 2.用一个静态变量保存这个唯一的实例 29 * 3、提供一个静态方法，获取这个实例对象 30 */ 31 private static Single05 instance; 32 private Single05(){ 33 } 34 public static Single05 getInstance() { 35 if (instance == null) { 36 synchronized (Single05.class) { 37 if (instance == null) { 38 instance = new Single05(); 39 } 40 } 41 } 42 return instance; 43 } 44 } 45 46 47 48 /** 49 * 在内部类被加载和初始化时，才创建instance对象 50 * 静态内部类不会自动随着外部类的加载和初始化而初始化，它是单独加载和初始化的。 51 * 在使用方法的时候才会初始化创建实例对象 52 * 因为是在内部类加载和初始化时，创建的，因此线程是安全的 53 */ 54 public class Single06 { 55 private Single06(){ 56 } 57 private static class Inner{ //静态内部类 58 private static final Single06 INSTANCE = new Single06(); 59 } 60 public static Single06 getInstance(){ 61 return Inner.INSTANCE; 62 } 63 }
上述是懒汉式创建实例对象，使用静态内部类最简单
原文：https://www.cnblogs.com/zsh-blog/p/14888778.html