在java中，单例有很多种写法，面试时，手写代码环节，除了写算法题，有时候也会让手写单例模式，这里记录一下单例的几种写法和优缺点。
1.初级写法
2.加锁
3.饿汉式
4.懒汉式
5.双锁检验
6.内部类
1.初级写法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package com.java4all.test6;/** * author: yunqing * date: 2018/8/13 * description:单例模式 -- 初级 */public class singleton { private static singleton singleton = null; public singleton() { } /**并发下会产生多个实例*/ public static singleton getinstance(){ if(singleton == null){ singleton = new singleton(); } return singleton; }} |
上面这种写法，在并发环境下，会出现多个实例。
2.加锁
我们优化上面的代码，遇到并发，很容易想到加锁，把获取对象的方法加上关键字synchronized，很巧，这种写法也称为懒汉式单例 ，如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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; }} |
但是，显然，我们把整个方法都同步了，效率很低下，我们可以继续优化，只在创建实例的地方加上同步，参考5双锁检验。
3.饿汉式
饿汉式的特点是：类在加载时就直接初始化了实例。即使没用到，也会实例化。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
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; }} |
4.懒汉式
懒汉式的特点是：用到这个实例时才去调用方法实例化。这个和2中的看起来是一样的，因为这个实例化方法加了synchronized ，这样安全一些。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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; }} |
5.双锁检验
双重非空判断，new对象前加一次锁。
volatile关键字，考虑的是，new关键字在虚拟机中执行时其实分为很多步骤，具体原因可以参考深入理解java虚拟机一书（考虑的是这个new关键字字节码执行时是非原子性的），而volatile关键字可以防止指令重排。
|
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
|
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; }} |
6.内部类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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(); }} |
总结
以上所述是小编给大家介绍的java中的6种单例写法，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持！
原文链接：https://blog.csdn.net/weixin_39800144/article/details/84500676
