并发-单例模式

Posted 2020-10-12 Mr.袋鼠

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了并发-单例模式相关的知识，希望对你有一定的参考价值。

这里系统的说一下单例模式。

本文参考的文章,地址如下：

微信公众号：Java后端技术

文章：Java多线程编程-（12）-单例模式几种写法的错与对

作者：徐刘根

主要是四大类：饿汉、懒汉、双重校验锁DCL、

1.饿汉模式

示例如下：

 1 public class Singleton {
 2 
 3     /*为了防止外部访问，所以实例是private的
 4     为了在static方法中访问，所以必须是static
 5     至于为什么，叫饿汉模式。我想，因为在程序走到下面这一行时，
 6     会初始化，调用构造方法。在没有调用getInstance方法时，就创建好了实例。
 7     因为，可能叫做饿汉模式吧*/
 8     private static Singleton singleton = new Singleton();
 9     
10     private Singleton() {
11         System.out.println("666");
12     }
13     public static Singleton getInstance() {
14         return singleton;
15     }
16 }

2.懒汉模式

示例如下：

 1 public class SingletonByLazy {
 2 
 3     private static SingletonByLazy singleton;
 4     
 5     /*这里必须是private修饰符，否则，就可以new多个对象，这是单例模式最基本的保证*/
 6     private SingletonByLazy() {}
 7     
 8     /*需要注意的是，必须加上synchronized关键字。否则会导致对象的访问变得不安全。
 9      * 饿汉的优点是延迟加载，在你需要的时候进行加载。缺点是必须使用同步*/
10     public static synchronized SingletonByLazy getInstance() {
11         if (singleton == null) {
12             singleton = new SingletonByLazy();
13         }
14         return singleton;
15     }
16 }

3.双重校验锁DCL

代码比上面两种多一些，绕一些，但是思想还是值得学习的嘛！看下面的例子：

 1 public class SingletonByDCL {
 2 
 3     /*这里切记，volatile关键字不可以缺少。
 4      * 不然会因为指令重排，导致在第一个判空时，将未初始化的对象返回。*/
 5     private volatile static SingletonByDCL singleton;
 6     
 7     /*这里必须是private修饰符，否则，就可以new多个对象，这是单例模式SingletonByLazy.java最基本的保证*/
 8     private SingletonByDCL() {}
 9     
10     /*需要注意的是，必须加上synchronized关键字。否则会导致对象的访问变得不安全。
11      * 饿汉的优点是延迟加载，在你需要的时候进行加载。缺点是必须使用同步*/
12     public static SingletonByDCL getInstance() {
13         if (singleton == null) {
14             synchronized (SingletonByDCL.class) {
15                 if (singleton == null) {
16                     singleton = new SingletonByDCL();
17                 }
18             }
19         }
20         return singleton;
21     }
22 }

4.静态内部类

 1 public class SingletonByStaticClass {
 2 
 3     /*通过类加载机制，保证创建单一对象*/
 4     private static class SingletonHolder {
 5         private static final SingletonByStaticClass single = new SingletonByStaticClass();
 6     }
 7     
 8     private SingletonByStaticClass() {}
 9     
10     /*对于JAVA的加载机制来说，当第一次访问类的静态字段时，会触发类的加载*/
11     public static SingletonByStaticClass getInstance() {
12         return SingletonHolder.single;
13     }
14 }

接下来，我要单独说一下static关键字。因为非常重要。

小例子：

 1 public class Test {
 2 
 3     public void method01(){
 4         System.out.println("method01");
 5     }
 6     
 7     public static void method02(){
 8         System.out.println("method02");
 9     }
10     
11     public static void main(String args[]){
12         new Test().method01();
13         method02();
14     }
15 }
16 
17 
18 执行结果：
19 method01
20 method02