单利模式的两种最佳实现

时间 2019-12-05

标签单利模式两种最佳实现繁體版

原文原文链接

在23种设计模式中单利模式算是比较简单的一种设计模式了，虽然简单，可是他的实现却有不少种。下面会给出两种最佳实现和其余一些常见的实现方式。设计模式

单元素枚举

不须要延迟加载时的最佳实现安全

public enum Singleton {

    //每一个元素就是一个单例
    INSTANCE;

    //业务方法
    public void method(){}
}
复制代码

优势：bash

能防止反射
能防序列化
线程安全
调用效率高

缺点：优化

不能延时加载

静态内部类

须要延迟加载时的最佳实现ui

public class Singleton {

    //1. 建立私有的 静态内部类
    private static class inner {
        //1.1 在静态内部类里，建立 私有的 静态的 外部类对象
        private static Singleton instance = new Singleton();
    }

    //2. 私有化构造器，禁止他人建立实例
    private Singleton() {
    }

    //3. 建立 公开的 静态的 获取实例的方法
    public static  Singleton getInstance() {
        return inner.instance;
    }
}
复制代码

优势：spa

线程安全
调用效率高
能延时加载

缺点：线程

不能能防止反射
不能防序列化

饿汉式

public class Singleton  {
    //1. 建立私有的 静态的内部实例
    private static Singleton instance = new Singleton();

    //2. 私有化构造器，禁止他人建立实例
    private  Singleton(){}

    //3. 建立 公开的 静态的 获取实例的方法
    public static Singleton getInstance(){
        return instance;
    }
}
复制代码

优势：设计

线程安全
调用效率高

缺点：code

不能能防止反射
不能防序列化
不能延时加载

懒汉式

public class Singleton {
    //1. 建立私有的 静态的内部实例,并初始化为null
    private static  Singleton instance  = null;

    //2. 私有化构造器，禁止他人建立实例
    private Singleton() {
    }

    //3. 建立 公开的 静态的 获取实例的方法
    public static  Singleton getInstance() {
        // 先判断单例是否为空，以免重复建立
        if( instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}
复制代码

优势：对象

能延时加载缺点：
不能能防止反射
不能防序列化
线程不安全
调用效率不高

懒汉式 + 同步锁

public class Singleton {
    //1. 建立私有的 静态的内部实例,并初始化为null
    private static  Singleton instance  = null;

    //2. 私有化构造器，禁止他人建立实例
    private Singleton() {
    }

    //3. 建立 公开的 静态的 获取实例的方法
    public static synchronized Singleton getInstance() {
        // 加入同步锁
        if (instance == null)
            instance = new Singleton();
        return instance;
    }
}
复制代码

优势：

能延时加载
线程安全缺点：
不能能防止反射
不能防序列化
调用效率不高

双重校验锁（懒汉式的改进）

注意：JVM的指令重排序，可能会致使双重校验锁失效

public class Singleton {
    //1. 建立私有的 静态的内部实例,并初始化为null
    private static  Singleton instance  = null;

    //2. 私有化构造器，禁止他人建立实例
    private Singleton() {
    }

    //3. 建立 公开的 静态的 获取实例的方法
    public static  Singleton getInstance() {
        // 加入双重校验锁
        // 校验锁1：第1个if
        if( instance == null){
            synchronized (Singleton.class){
                // 校验锁2：第2个 if
                if( instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
复制代码

优势：

能延时加载
线程安全缺点：
不能能防止反射
不能防序列化
调用效率不高

双重校验锁优化（规避指令重排序的影响）

使用 volatile 关键字来防止指令重排序

public class Singleton {
    //1. 建立私有的 静态的 可见的 内部实例,并初始化为null
    private static volatile Singleton instance  = null;

    //2. 私有化构造器，禁止他人建立实例
    private Singleton() {
    }

    //3. 建立 公开的 静态的 获取实例的方法
    public static  Singleton getInstance() {
        // 加入双重校验锁
        // 校验锁1：第1个if
        if( instance == null){
            synchronized (Singleton.class){
                // 校验锁2：第2个 if
                if( instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
复制代码

优势：

能延时加载
线程安全缺点：
不能能防止反射
不能防序列化
调用效率不高