饿汉式
类加载到内存后,就实例化一个单例,JVM保证线程安全
简单实用,推荐使用
唯一缺点:不管是否用到与否,类装载时就完成实例化
public class Mgr01 { //2、通过静态常量获取初始化 private static final Mgr01 INSTANCE = new Mgr01(); //1、私有化构造方式,确保其他类创建不了 private Mgr01() { } //3、外部只能通过此方式获取该类对象 public static Mgr01 getInstance(){ return INSTANCE; } public void m(){ System.out.println("m"); } //测试 public static void main(String[] args) { Mgr01 m1 = Mgr01.getInstance(); Mgr01 m2 = Mgr01.getInstance(); System.out.println(m1==m2); } }
比较而言,第二种只不过是那static初始化了一下INSTANCE
public class Mgr02 { private static final Mgr02 INSTANCE ; static{ INSTANCE = new Mgr02(); } private Mgr02() { } public static Mgr02 getInstance(){ return INSTANCE; } public void m(){ System.out.println("m"); } public static void main(String[] args) { Mgr02 m1 = Mgr02.getInstance(); Mgr02 m2 = Mgr02.getInstance(); System.out.println(m1==m2); } }懒汉式
懒汉式
lazy loading
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(); } } }
运行main方法会发现我们使用的对象的hashCode地址不一样
可以通过synchronized解决,但也带来效率下降每次运行到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(); } } }双重检测锁 一重检测锁(此方法不产生效果)
public class Mgr05 { private static volatile 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(); } } }
因为synchronized在if里面,所以可能有多个线程同时进入if,导致单例模式失效,如果if写到synchronized里面,和方法synchronized一样,多以需要双重检测锁的
双重检测锁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; }
第二个if是前几次多个线程进入第一个if时,对这些INSTANCE的过滤,过滤之后将不会进入第二个if,不需要添加锁了,使效率提升
静态内部类静态内部类方式
JVM保证单例
加载外部类时不会加载内部类,这样可以实现懒加载
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(Mgr06.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(Mgr06.getInstance().hashCode())).start(); } } }
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)