什么是单例模式
单列模式是保证在内存之中只有一个实例
单列模式的八种写法
- 第一种写法饿汉式 类加载到内存后，就实例化一个单例，JVM保证线程安全。简单实用，推荐使用！缺点：不管用到与否，类装载时就完成实例化
public class Mgr01 { private static final Mgr01 INSTANCE = new Mgr01(); private Mgr01() {}; public static Mgr01 getInstance() { return INSTANCE; } public static void main(String[] args) { Mgr01 m1 = Mgr01.getInstance(); Mgr01 m2 = Mgr01.getInstance(); System.out.println(m1 == m2); } } 复制代码
- 第二种写法 饿汉式，跟第一种一样，只是放在静态代码快加载
public class Mgr02 { private static final Mgr02 INSTANCE; static { INSTANCE = new Mgr02(); } private Mgr02() {}; public static Mgr02 getInstance() { return INSTANCE; } public static void main(String[] args) { Mgr02 m1 = Mgr02.getInstance(); Mgr02 m2 = Mgr02.getInstance(); System.out.println(m1 == m2); } } 复制代码
- 第三种写法 懒汉式就是什么时候用的时候才初始化，虽然达到了按需初始化的目的，但却带来线程不安全的问题
public class Mgr03 { private static Mgr03 INSTANCE; private Mgr03() { } public static Mgr03 getInstance() { if (INSTANCE == null) { try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } INSTANCE = new Mgr03(); } return INSTANCE; } public void m() { System.out.println("m"); } public static void main(String[] args) { for(int i=0; i<100; i++) { new Thread(()-> System.out.println(Mgr03.getInstance().hashCode()) ).start(); } } } 复制代码
- 第四种写法,懒汉式的另一种写法synchronized解决，但也带来效率下降
public class Mgr04 { private static Mgr04 INSTANCE; private Mgr04() { } public static synchronized Mgr04 getInstance() { if (INSTANCE == null) { try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } INSTANCE = new Mgr04(); } return INSTANCE; } public void m() { System.out.println("m"); } public static void main(String[] args) { for(int i=0; i<100; i++) { new Thread(()->{ System.out.println(Mgr04.getInstance().hashCode()); }).start(); } } } 复制代码
- 第五种写法, 懒汉式妄图通过减小同步代码块的方式提高效率，在多线程访问情况下，不能保证只有一个Mgr05实例
public class Mgr05 { private static Mgr05 INSTANCE; private Mgr05() { } public static Mgr05 getInstance() { if (INSTANCE == null) { synchronized (Mgr05.class) { try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } INSTANCE = new Mgr05(); } } return INSTANCE; } public void m() { System.out.println("m"); } public static void main(String[] args) { for(int i=0; i<100; i++) { new Thread(()->{ System.out.println(Mgr05.getInstance().hashCode()); }).start(); } } } 复制代码
- 第六种方法 懒汉式 双重非空检查，还要加上volatile，因为在创建对象的时候，第二条指令和第三条指令会进行重排序。假设此时线程1通过第二次检查，在创建对象的过程中，第二条指令和第三条指令出现重排序，此时INSTANCE指向的是一个半初始化的对象。如果在这个时候线程2进来了，在执行第一次检查的时候发现INSTANCE并非为空，这时就直接返回了半初始化的INSTANCE，从而会出现问题。
public class Mgr06 { private static volatile Mgr06 INSTANCE; //JIT private Mgr06() { } public static Mgr06 getInstance() { if (INSTANCE == null) { //双重检查 synchronized (Mgr06.class) { if(INSTANCE == null) { try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } INSTANCE = new Mgr06(); } } } return INSTANCE; } public void m() { System.out.println("m"); } public static void main(String[] args) { for(int i=0; i<100; i++) { new Thread(()->{ System.out.println(Mgr06.getInstance().hashCode()); }).start(); } } } 复制代码
- 第七种方法 静态内部类写法，加载外部类时不会加载内部类，这样可以实现懒加载
public class Mgr07 { private Mgr07() { } private static class Mgr07Holder { private final static Mgr07 INSTANCE = new Mgr07(); } public static Mgr07 getInstance() { return Mgr07Holder.INSTANCE; } public void m() { System.out.println("m"); } public static void main(String[] args) { for(int i=0; i<100; i++) { new Thread(()->{ System.out.println(Mgr07.getInstance().hashCode()); }).start(); } } } 复制代码
- 第八种写法，枚举单例不仅可以解决线程同步。还可以防止反序列化，最完美的写法，枚举类没有办法反序列化，是因为枚举类没有构造方法，所以没办法反序列化
public enum Mgr08 { INSTANCE; public void m() {} public static void main(String[] args) { for(int i=0; i<100; i++) { new Thread(()->{ System.out.println(Mgr08.INSTANCE.hashCode()); }).start(); } } }
