【面试】字节跳动提前批笔试题：实现三种线程安全的单例模式

最新推荐文章于 2024-04-17 10:12:47 发布

原创最新推荐文章于 2024-04-17 10:12:47 发布 · 912 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#单例模式 #面试

面试专栏收录该内容

1 篇文章

订阅专栏

本文深入探讨了单例模式的四种实现方式：饿汉模式、懒汉模式、双重检测锁模式和静态内部类式，以及枚举类实现。饿汉模式在类加载时创建实例，线程安全且调用效率高；懒汉模式在首次调用时创建实例，虽线程安全但调用效率较低；双重检测锁模式理论上可提高效率，但因JVM底层模型可能存在问题；静态内部类式结合了饿汉和懒汉的优点；枚举类则提供了天然的单例实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

饿汉模式

线程安全，调用效率高，但是不能延时加载：


public class hungery {
	//类初始化时立即加载对象(没有延迟加载的优势)，天然的线程安全
	private static hungery instance=new hungery();
	private hungery(){};
	//方法没有同步，调用效率高
	public static hungery getinstance(){
		return instance;
	}
	public static void main(String[] args) {
		hungery instance2=new hungery();
		System.out.print(instance2.getinstance()==hungery.instance);
	}

}

懒汉模式

线程安全，调用效率不高，但是能延时加载：

public class lazymodel {
	private static lazymodel singleton=null;
    //懒汉式 synchronized锁方法实现
	public static synchronized lazymodel getinstance(){
		if(singleton==null){
			singleton=new lazymodel();
		}
		return singleton;
	} 
	public static void main(String[] args) {
		lazymodel instance2=new lazymodel();
		System.out.print(instance2.getinstance()==lazymodel.getinstance());
	}
}

双重检测锁模式

由于JVM底层模型原因，偶尔会出问题，不建议使用


public class duplicationcheck {
	  /*
                         懒汉式  双重检查锁
     */
    //volatile保证可见性，读值需要访问主内存
	private static volatile duplicationcheck Single=null;
	public duplicationcheck getSingle(){
		if(Single==null){
			synchronized(duplicationcheck.class){
				//原子性，可见性
				if(Single==null){
					Single=new duplicationcheck();
				}
			}
		}
		return Single;
	}
	public static void main(String[] args) {
		duplicationcheck single=new duplicationcheck();
		System.out.print(single.getSingle()==new duplicationcheck().getSingle());
	}
}

附另外两种

静态内部类式（线程安全，调用效率高，可以延时加载）


public class LazyIner {
    /*
    懒汉式 静态内部类实现
     */
	public static class getsinglen{
		static LazyIner  LazyIner=new LazyIner();
	}
	public static void main(String[] args) {
		System.out.println(getsinglen.LazyIner == getsinglen.LazyIner);

	}
}

枚举类（线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用）

public enum LazyEnum {
	INSTANCE;
}

在另一个main方法中调用

		System.out.print(LazyEnum.INSTANCE==LazyEnum.INSTANCE);