单例模式的五种写法

一、饿汉式单例

饿汉式单例模式，实例对象在初始化的时候创建，不管有没有得到调用。好处是没有线程安全的问题，坏处是浪费内存空间。

//饿汉式单例 public class ehan { /** * 存在的问题： * 饿汉式强调的是一上来就初始化对象，初始化的对象里面又有很多像如下定义的很多数组同时也被初始化， * 但没有得到调用，就会存在浪费空间的情况 * */ private byte[] data1 = new byte[1024*1024]; private byte[] data2 = new byte[1024*1024]; private byte[] data3 = new byte[1024*1024]; private byte[] data4 = new byte[1024*1024]; //构造器私有，保证别的方法无法调用生成这个对象 private ehan(){} //实例对象初始化时创建 private static final ehan HUNGRY = new ehan(); public static ehan getInstance(){ return HUNGRY; } public static void main(String[] args) { ehan ehan1 = ehan.getInstance(); ehan ehan2 = ehan.getInstance(); System.out.println(ehan1==ehan2);//true } }

---

二、懒汉式

我们知道饿汉式在初始化的时候就完成了对象的创建，但存在浪费空间的问题，因此，懒汉式单例模式应运而生。 懒汉式顾名思义就是只有当需要的时候才会去初始化数据。

//懒汉式单例模式 public class lanhan { //构造器私有 private lanhan(){ } private static lanhan lazyMan; public static lanhan getInstance(){ if(lazyMan==null){ lazyMan = new lanhan(); } return lazyMan; } public static void main(String[] args) { lanhan instance1 = lanhan.getInstance(); lanhan instance2 = lanhan.getInstance(); System.out.println(instance1==instance2); } }

---

三、DCL（Double Check Lock）懒汉式

由于上述的懒汉式在单线程里确实是安全的，但是在多线程中，其实是并不安全的，我们可以通过以下代码测试： 我们会发现，得出的结果并不是单例的。

//懒汉式单例模式 public class lanhan { //构造器私有 private lanhan(){ System.out.println(Thread.currentThread().getName()+"OK"); } private static lanhan lazyMan; public static lanhan getInstance(){ if(lazyMan==null){ lazyMan = new lanhan(); } return lazyMan; } /** * 单线程下确实单例安全，但是多线程下是存在安全问题的 * 我们得加锁 * */ public static void main(String[] args) throws InterruptedException { for (int i = 0; i < 10; i++) { new Thread(()->{ lanhan.getInstance(); }).start(); } TimeUnit.SECONDS.sleep(3); lanhan instance1 = lanhan.getInstance(); lanhan instance2 = lanhan.getInstance(); System.out.println(instance1==instance2); } }

因此我们得给他上锁，保证一个线程只能创建一个对象，也有且只能有一个对象。同时为了防止指令重排现象出现，我们得对变量加volatile锁。

//DCL懒汉式单例模式 public class lanhan { //构造器私有 private lanhan(){ System.out.println(Thread.currentThread().getName()+"OK"); } //防止指令重排 private static volatile lanhan lazyMan; //双重检测锁模式--DCL懒汉式检测 public static lanhan getInstance(){ //先判断有没有对象实例被创建，没有的话就锁住这个类，确保只有一个Class对象 if(lazyMan==null){ synchronized (lanhan.class){ if(lazyMan==null){ //但是还可能存在一个问题，因为new lanhan()不是一个原子操作 /* * 1.分配内存 * 2.执行构造方法 * 3.指向地址 * 有可能存在的问题就是由于指令重排，它的执行顺序完全有可能是132，这个时候由于指向了内存地址， * 会被以为创建了对象，导致无法创建对象，为了保证不发生指令重排现象，我们必须加上volatile关键字 * */ lazyMan = new lanhan(); } } } return lazyMan; } public static void main(String[] args) throws InterruptedException { for (int i = 0; i < 10; i++) { new Thread(()->{ lanhan.getInstance(); }).start(); } TimeUnit.SECONDS.sleep(3); lanhan instance1 = lanhan.getInstance(); lanhan instance2 = lanhan.getInstance(); System.out.println(instance1==instance2); } }

---

四、静态内部类

可以延时加载，并且线程安全

//静态内部类实现 public class Holder { //构造器私有 private Holder(){ } public static Holder getInstance(){ return InnerClass.HOLDER; } //静态内部类 public static class InnerClass{ private static final Holder HOLDER = new Holder(); } public static void main(String[] args) { Holder instance = Holder.getInstance(); Holder instance2 = Holder.getInstance(); System.out.println(instance==instance2); } }

---

五、反射破坏单例模式

java中存在反射机制，能够改变内部的private关键字，因此使用private修饰的其实都不算是安全的，由此引出枚举单例模式。

//反射破坏单例模式 public class fanshe { //构造器私有 private fanshe(){ System.out.println(Thread.currentThread().getName()+"OK"); } private static volatile fanshe lazyMan; public static fanshe getInstance(){ if(lazyMan==null){ synchronized (fanshe.class){ if(lazyMan==null){ lazyMan = new fanshe(); } } } return lazyMan; } public static void main(String[] args) throws Exception { fanshe instance = fanshe.getInstance(); //利用反射获取其对应的构造器方法 Constructor<fanshe> declaredConstructor = fanshe.class.getDeclaredConstructor(null); //无视私有构造器，通过反射创建对象 declaredConstructor.setAccessible(true); fanshe instance2 = declaredConstructor.newInstance(); System.out.println(instance==instance2); } }

如何解决反射破坏单例现象？第一种方法，我们可以在构造器里面对类加锁。

//反射破坏单例模式 public class fanshe { //构造器私有 private fanshe(){ synchronized (fanshe.class){ if(lazyMan==null){ throw new RuntimeException("不要试图使用反射破坏异常"); } } } private static volatile fanshe lazyMan; public static fanshe getInstance(){ if(lazyMan==null){ synchronized (fanshe.class){ if(lazyMan==null){ lazyMan = new fanshe(); } } } return lazyMan; } public static void main(String[] args) throws Exception { fanshe instance = fanshe.getInstance(); //利用反射获取其对应的构造器方法 Constructor<fanshe> declaredConstructor = fanshe.class.getDeclaredConstructor(null); //无视私有构造器，通过反射创建对象 declaredConstructor.setAccessible(true); fanshe instance2 = declaredConstructor.newInstance(); System.out.println(instance==instance2); } }

但是上面那种方法治标不治本，因为第一个instance我们是通过getInstance方法创建的，没经过反射，如果我们两个对象都是通过反射创建，如下代码所示，还是会存在问题。

//反射破坏单例模式 public class fanshe { //构造器私有 private fanshe(){ synchronized (fanshe.class){ if(lazyMan!=null){ throw new RuntimeException("不要试图使用反射破坏异常"); } } } private static volatile fanshe lazyMan; public static fanshe getInstance(){ if(lazyMan==null){ synchronized (fanshe.class){ if(lazyMan==null){ lazyMan = new fanshe(); } } } return lazyMan; } public static void main(String[] args) throws Exception { //fanshe instance = fanshe.getInstance(); //利用反射获取其对应的构造器方法 Constructor<fanshe> declaredConstructor = fanshe.class.getDeclaredConstructor(null); //无视私有构造器，通过反射创建对象 declaredConstructor.setAccessible(true); fanshe instance2 = declaredConstructor.newInstance(); fanshe instance3 = declaredConstructor.newInstance(); System.out.println(instance3==instance2); } }

由此引入第二种方法，通过定义一个信号量来解决：

//反射破坏单例模式 public class fanshe { //定义一个信号量 private static boolean flag = false; //构造器私有 private fanshe(){ synchronized (fanshe.class){ //通过反射的方式无法获取到这个信号量，因此不能通过反射创建 if(flag==false){ flag=true; } else{ throw new RuntimeException("不要试图使用反射破坏异常"); } } } private static volatile fanshe lazyMan; public static fanshe getInstance(){ if(lazyMan==null){ synchronized (fanshe.class){ if(lazyMan==null){ lazyMan = new fanshe(); } } } return lazyMan; } public static void main(String[] args) throws Exception { //fanshe instance = fanshe.getInstance(); //利用反射获取其对应的构造器方法 Constructor<fanshe> declaredConstructor = fanshe.class.getDeclaredConstructor(null); //无视私有构造器，通过反射创建对象 declaredConstructor.setAccessible(true); fanshe instance2 = declaredConstructor.newInstance(); fanshe instance3 = declaredConstructor.newInstance(); System.out.println(instance3==instance2); } }

---

六、枚举单例

利用枚举的方式创建单例模式，可以避免反射对其内部进行关键字的破坏，继而导致单例模式失效。它的缺点也是不能延时加载

public enum meiju{ INSTANCE; public meijugetInstance(){ return INSTANCE; } } class test05{ public static void main(String[] args) { meijuinstance1 = SingletonTest05.INSTANCE; meijuinstance2 = SingletonTest05.INSTANCE; System.out.println(instance1==instance2); } }