美文网首页
简单&易懂的线程安全单例模式

简单&易懂的线程安全单例模式

作者: 细雨蒙情 | 来源:发表于2018-06-15 21:46 被阅读23次

    1.前言

    单例模式是23种设计模式中最常见的设计模式之一,正确编写单例模式是每个程序员都需要掌握的技术,单例模式也是面试中经常考察的内容,下面以一个面试题开始讲解今天的内容:

    手写一个线程安全的单例,并分析为什么是线程安全的?如何防止反射实例化单例对象?
    

    2.单例模式介绍

    2.1 定义

    数学与逻辑学中,singleton定义为“有且仅有一个元素的集合”。
    单例模式最初的定义出现于《设计模式》(艾迪生维斯理, 1994):“保证一个类仅有一个实例,并提供一个访问它的全局访问点。”
    Java中单例模式定义:“一个类有且仅有一个实例,并且自行实例化向整个系统提供。”

    2.2 实现要点
    单例模式的实现要点包括:

    • 构造函数私有化
    • 提供一个类方法,用于获取实例
    • 注意线程安全
        public class Singleton {
     //构造方法私有化,不让外部通过new创建多个实例
            private Singleton() {
            }
    //类的静态私有对象,作为全局唯一访问点
            private static Singleton instance = null;
    //提供公有的静态方法供外部调用,返回单例类的唯一实例
            public static  synchronized Singleton getInstance(){
                if(instance==null){
                       instance=new Singleton();
                }
                return instance;
            }
    
            
        }
    

    3.线程安全的单例模式

    3.1 饿汉模式

    public class Singleton {
        
    private static Singleton singleton = new Singleton();
        private Singleton() {
        }
    
        public static Singleton getInstance() {
            return singleton;
        }
    
    }
    

    要理解饿汉模式为什么是线程安全的需要了解JVM的类的加载机制。
    Java中的所有类,都需要由类加载器装载到JVM中才能运行。什么时候会触发类的加载呢?当使用new创建实例化对象,读取或者设置一个类的静态字段,调用一个类的静态方法时,JVM会去检查这个类编译得到的class文件是否被已经被加载进来,没有的话就把类加载到虚拟机内存中,并对数据进行校验、转换解析和初始化,最终形成可以被直接使用的Java类型。初始化过程会调用类的构造器方法<clinit>,<clinit>方法会为类变量进行赋值,同时虚拟机会保证<clinit>在多线程环境下被正确地加锁、同步。
    结合到饿汉模式:
    当我们在外部调用Singleton.getgetInstance()时,因为getgetInstance是类方法,此时虚拟机会去检查Singleton.class是否被加载到虚拟机内存,如果没有,那么就会触发虚拟机的类加载机制,最终进行到初始化阶段时,对类变量singleton 进行赋值,也就是执行

    private static Singleton singleton = new Singleton();
    

    同时虚拟机会保证在执行 new Singleton()时线程安全的,最后返回singleton ;如果发现Singleton.class已经被加载过了,则直接返回singleton 。

    3.2 双重校验锁(DCL)

    public class Singleton {
            private Singleton() {
            }
    
            private static volatile Singleton instance = null;
    
            public static Singleton getInstance() {
                if (instance == null) {
                    synchronized (Singleton.class) {
                        if (instance == null) {
                            instance = new Singleton();
                        }
                    }
    
                }
                return instance;
            }
    
        }
    
    1. memory = allocate(); //1:分配对象的内存空间
    2. ctorInstance(memory); //2:初始化对象
    3. instance = memory; //3:设置instance指向刚分配的内存地址
      但是经过重排序后如下:
    4. memory = allocate(); //1:分配对象的内存空间
    5. instance = memory; //3:设置instance指向刚分配的内存地址
      //注意,此时对象还没有被初始化!
    6. ctorInstance(memory); //2:初始化对象
      将第2步和第3步调换顺序,在单线程情况下不会影响程序执行的结果,但是在多线程情况下就不一样了。线程A执行了instance = memory(这对另一个线程B来说是可见的),此时线程B执行外层 if (instance == null),发现instance不为空,随即返回,但是得到的却是未被完全初始化的实例,在使用的时候必定会有风险,这正是双重检查锁定的问题所在!

    3.3 内部类延迟加载

    public class Singleton{
        private Singleton(){}
        private  static class SingletonHolder{
            public final static Singleton instance = new Singleton();
        }
    
        public static Singleton getInstance(){
            return SingletonHolder.instance;
        }
    }
    

    相关文章

      网友评论

          本文标题:简单&易懂的线程安全单例模式

          本文链接:https://www.haomeiwen.com/subject/chadkftx.html