在java中,单例有很多种写法,面试时,手写代码环节,除了写算法题,有时候也会让手写单例模式,这里记录一下单例的几种写法和优缺点。 1.初级写法 2.加锁 3.饿汉式 4.懒汉式 5.双锁检验 6.内部类 1.初级写法 package com.java4all.test6;
/** * Author: yunqing * Date: 2018/8/13 * Description:单例模式 -- 初级 */ public class Singleton {
private static Singleton singleton = null;
private Singleton() { }
/**并发下会产生多个实例*/ public static Singleton getInstance(){ if(singleton == null){ singleton = new Singleton(); } return singleton; } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 上面这种写法,在并发环境下,会出现多个实例。
2.加锁 我们优化上面的代码,遇到并发,很容易想到加锁,把获取对象的方法加上关键字synchronized,很巧,这种写法也称为懒汉式单例 ,如下:
package com.java4all.test6;
/** * Author: yunqing * Date: 2018/8/13 * Description: */ public class BadSynchronizedSingleton { private static BadSynchronizedSingleton synchronizedSingleton;
private BadSynchronizedSingleton() { }
/** * 缺点:等待时间长 * 这种整个方法都同步了,效率很低 * */ public synchronized static BadSynchronizedSingleton getInstance(){ if(synchronizedSingleton == null){ synchronizedSingleton = new BadSynchronizedSingleton(); } return synchronizedSingleton; } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 但是,显然,我们把整个方法都同步了,效率很低下,我们可以继续优化,只在创建实例的地方加上同步,参考5双锁检验。
3.饿汉式 饿汉式的特点是:类在加载时就直接初始化了实例。即使没用到,也会实例化。
package com.java4all.test6;
/** * Author: yunqing * Date: 2018/8/13 * Description:饿汉式单例模式--类初始化时就自行实例化 */ public class ESingleton {
/**类在加载的时候直接进行初始化*/ private static final ESingleton ESINGLETON = new ESingleton();
private ESingleton() {}
/**对外暴露唯一接口 提供单例对象*/ public static ESingleton geteSingleton(){ return ESINGLETON; } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 4.懒汉式 懒汉式的特点是:用到这个实例时才去调用方法实例化。这个和2中的看起来是一样的,因为这个实例化方法加了synchronized ,这样安全一些。
package com.java4all.test6;
/** * Author: yunqing * Date: 2018/8/13 * Description:懒汉式单例模式 * 第一次调用时实例化 */ public class BSingleton { private static BSingleton bSingleton ;
private BSingleton() { }
/** * 整个方法锁住了,效率较低 * @return */ public synchronized static BSingleton getbSingleton(){ if(bSingleton == null){ bSingleton = new BSingleton(); } return bSingleton; } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 5.双锁检验 双重非空判断,new对象前加一次锁。
volatile关键字,考虑的是,new关键字在虚拟机中执行时其实分为很多步骤,具体原因可以参考深入理解java虚拟机一书(考虑的是这个new关键字字节码执行时是非原子性的),而volatile关键字可以防止指令重排。
package com.java4all.test6;
/** * Author: yunqing * Date: 2018/8/13 * Description:双锁检验 */ public class SynchronizedSingleton {
/**volatile防止指令重排*/ private static volatile SynchronizedSingleton singleton;
private SynchronizedSingleton() { }
/**只是在实例为空时才进行同步创建 * 为什么做了2次判断? * A线程和B线程同时进入同步方法0 * 然后都在1位置处判断了实例为null * 然后都进入了同步块2中 * 然后A线程优先进入了同步代码块2中(B线程也进入了),然后创建了实例 * 此时,如果没有3处的判断,那么A线程创建实例同时,B线程也会创建一个实例 * 所以,还需要做2次判断 * */ public static SynchronizedSingleton getInstance(){//0 if(singleton == null){//1 synchronized (SynchronizedSingleton.class){//2 if(singleton == null){//3 singleton = new SynchronizedSingleton();//4 } } } return singleton; } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 6.内部类 package com.java4all.test6;
/** * Author: yunqing * Date: 2018/9/15 * Description:静态内部类 * 优点:1.延迟,外部类初始化时不会进行实例创建,要用时才会创建 * 2.安全,静态成员变量 */ public class FSingleton {
private FSingleton() { }
public static FSingleton getInstance(){ return Singleton.fSingleton; }
private static class Singleton{ private static FSingleton fSingleton = new FSingleton(); } }
--------------------- 作者:lightClouds917 来源:CSDN 原文:https://blog.csdn.net/weixin_39800144/article/details/84500676 版权声明:本文为博主原创文章,转载请附上博文链接!
|