关于单例模式

时间  2021-08-14
标签 java 程序员 面试 sql 安全 markdown 网络 并发 ide 函数 栏目 Java 繁體版
原文   原文链接

单例模式不管是在实际项目开发仍是面试中，都是常常会涉及到，今天总结一下什么样的单例模式才是正确的。java

1. 存在问题的单例模式

1.1 线程不安全的懒汉式

/** * Created by zhoujunfu on 2016/8/24. * 线程不安全的懒汉式单例 */
class SingletonLazyNonThreadSafe {

    private static SingletonLazyNonThreadSafe instance;

    private SingletonLazyNonThreadSafe() {
        System.out.println("初始化单例对象：" + this.hashCode());
    }

    public static SingletonLazyNonThreadSafe getInstance() {
        if (instance == null) {
            instance =  new SingletonLazyNonThreadSafe();
        }

        System.out.println("获取单例对象：" + instance.hashCode());
        return instance;
    }

}

class Runner implements Runnable {

    @Override
    public void run() {
        SingletonLazyNonThreadSafe.getInstance();
    }
}

public class SingletonDemo {

    public static void main(String[] args) throws InterruptedException {
        // 两个线程并发访问单例类建立实例
        Runner runnerOne = new Runner();
        Runner runnerTwo = new Runner();

        Thread threadOne = new Thread(runnerOne);
        Thread threadTwo = new Thread(runnerTwo);

        threadOne.start();
        threadTwo.start();
    }

}
复制代码

懒汉式，也是最想固然的单例方式，线程不安全，能够从如下运行结果看出，线程并发访问这种单例类时，会初始化多个实例，违反了单例类的原则，若是在两个线程start的代码中间加入线程休眠时间，这样后运行的线程才能拿到先运行线程建立的单例对象。程序员

1.2 线程安全的懒汉式

/** * Created by zhoujunfu on 2016/8/24. * 懒汉式单例 */
class SingletonLazyThreadSafe {

    private static SingletonLazyThreadSafe instance;

    private SingletonLazyThreadSafe() {
        System.out.println("初始化单例对象：" + this.hashCode());
    }

    public static synchronized SingletonLazyThreadSafe getInstance() {
        if (instance == null) {
            instance =  new SingletonLazyThreadSafe();
        }

        System.out.println("获取单例对象：" + instance.hashCode());
        return instance;
    }

}
class Runner implements Runnable {

    @Override
    public void run() {
        SingletonLazyThreadSafe.getInstance();
    }
}

public class TestSingleton {

    public static void main(String[] args) throws InterruptedException {
        // 两个线程并发访问单例类建立实例
         Runner runnerOne = new Runner();
        Runner runnerTwo = new Runner();

        Thread threadOne = new Thread(runnerOne);
        Thread threadTwo = new Thread(runnerTwo);

        threadOne.start();
        threadTwo.start();
    }

}
复制代码

经过将整个getInstance方法设为同步的，来保证每次只能有一个线程进入到建立/获取实例的方法内，虽然作到了线程安全，而且解决了多实例的问题，可是它并不高效。由于在任什么时候候只能有一个线程调用 getInstance() 方法。可是同步操做只须要在第一次调用时才被须要，即第一次建立单例实例对象时。面试

1.3 双重检验锁

/** * Created by zhoujunfu on 2016/8/24. * 懒汉式双重检查锁 */
class SingletonDoubleCheck {
    private SingletonDoubleCheck() {
        System.out.println("初始化单例对象：" + this.hashCode());
    }

    private static SingletonDoubleCheck instance;

    public static SingletonDoubleCheck getInstance() {
        if (instance == null) {
            synchronized (SingletonDoubleCheck.class) {
                if (instance == null) {
                    instance = new SingletonDoubleCheck();
                }
            }
        }
        return instance;
    }
}
复制代码

双重检验锁模式（double checked locking pattern），是一种使用同步块加锁的方法。程序员称其为双重检查锁，由于会有两次检查 instance == null，一次是在同步块外，一次是在同步块内。为何在同步块内还要再检验一次？由于可能会有多个线程一块儿进入同步块外的 if，若是在同步块内不进行二次检验的话就会生成多个实例了。
这段代码看起来很完美，很惋惜，它是有问题。主要在于instance = new Singleton()这句，这并不是是一个原子操做，事实上在 JVM 中这句话大概作了下面 3 件事情。
1.给 instance 分配内存
2.调用 Singleton 的构造函数来初始化成员变量
3.将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）
可是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序多是 1-2-3 也多是 1-3-2。若是是后者，则在 3 执行完毕、2 未执行以前，被线程二抢占了，这时 instance 已是非 null 了（但却没有初始化），因此线程二会直接返回 instance，而后使用，而后瓜熟蒂落地报错。
咱们只须要将 instance 变量声明成 volatile 就能够了。有些人认为使用 volatile 的缘由是可见性，也就是能够保证线程在本地不会存有 instance 的副本，每次都是去主内存中读取。但实际上是不对的。使用 volatile 的主要缘由是其另外一个特性：禁止指令重排序优化。也就是说，在 volatile 变量的赋值操做后面会有一个内存屏障（生成的汇编代码上），读操做不会被重排序到内存屏障以前。好比上面的例子，取操做必须在执行完 1-2-3 以后或者 1-3-2 以后，不存在执行到 1-3 而后取到值的状况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操做都先行发生于后面对这个变量的读操做（这里的“后面”是时间上的前后顺序）。
可是特别注意在 Java 5 之前的版本使用了 volatile 的双检锁仍是有问题的。其缘由是 Java 5 之前的 JMM （Java 内存模型）是存在缺陷的，即时将变量声明成 volatile 也不能彻底避免重排序，主要是 volatile 变量先后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复，因此在这以后才能够放心使用 volatile。sql

2. 不存在问题的单例模式

2.1 饿汉式（非懒加载）

class SingletonHungry {
    private SingletonHungry() {
        System.out.println("初始化单例对象：" + this.hashCode());
    }

    private static SingletonHungry instance = new SingletonHungry();

    public SingletonHungry getInstance() {
        return instance;
    }
}
复制代码

这种方法很是简单，由于单例的实例被声明成 static 和 final 变量了，在第一次加载类到内存中时就会初始化，因此建立实例自己是线程安全的。 这种写法若是完美的话，就不必在啰嗦那么多双检锁的问题了。缺点是它不是一种懒加载模式（lazy initialization），单例会在加载类后一开始就被初始化，即便客户端没有调用 getInstance()方法。饿汉式的建立方式在一些场景中将没法使用：譬如 Singleton 实例的建立是依赖参数或者配置文件的，在 getInstance() 以前必须调用某个方法设置参数给它，那样这种单例写法就没法使用了。安全

2.2 饿汉式（懒加载）

class SingletonStaticNestedClass {
    private SingletonStaticNestedClass() {
    }

    private static class Holder {
        private static final SingletonStaticNestedClass instance = new SingletonStaticNestedClass();
    }

    public SingletonStaticNestedClass getInstance() {
        return Holder.instance;
    }
}
复制代码

这种写法仍然使用JVM自己机制保证了线程安全问题；因为 Holder 是私有的，除了 getInstance() 以外没有办法访问它，所以它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本，但反序列化时会出现问题。markdown

2.3 枚举式（终极方法）

enum SingletonByEnum {
    INSTANCE;
}
复制代码

咱们能够经过EasySingleton.INSTANCE来访问实例，这比调用getInstance()方法简单多了。建立枚举默认就是线程安全的，因此不须要担忧double checked locking，并且还能防止反序列化致使从新建立新的对象。可是仍是不多看到有人这样写，多是由于不太熟悉吧。 网络上不少关于单例类的文章都介绍了用枚举法实现单例，但仅仅靠上述的例子还没法知道具体的使用方法，下面以一个具体的例子来讲明如何经过枚举实现单例类。网络

//Example 1
public enum MyDataBaseSource {
    DATASOURCE;
    private ComboPooledDataSource cpds = null;

    private MyDataBaseSource() {
        try {

            /*--------获取properties文件内容------------*/
            // 方法一:
            /* * InputStream is = * MyDBSource.class.getClassLoader().getResourceAsStream("jdbc.properties"); * Properties p = new Properties(); p.load(is); * System.out.println(p.getProperty("driverClass") ); */

            // 方法二：(不须要properties的后缀)
            /* * ResourceBundle rb = PropertyResourceBundle.getBundle("jdbc") ; * System.out.println(rb.getString("driverClass")); */

            // 方法三：(不须要properties的后缀)
            ResourceBundle rs = ResourceBundle.getBundle("jdbc");
            cpds = new ComboPooledDataSource();
            cpds = new ComboPooledDataSource();
            cpds.setDriverClass(rs.getString("driverClass"));
            cpds.setJdbcUrl(rs.getString("jdbcUrl"));
            cpds.setUser(rs.getString("user"));
            cpds.setPassword(rs.getString("password"));
            cpds.setMaxPoolSize(Integer.parseInt(rs.getString("maxPoolSize")));
            cpds.setMinPoolSize(Integer.parseInt(rs.getString("minPoolSize")));
            System.out.println("-----调用了构造方法------");
            ;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public Connection getConnection() {
        try {
            return cpds.getConnection();
        } catch (SQLException e) {
            return null;
        }
    }

}
public class Test {
    public static void main(String[] args) {
        MyDataBaseSource.DATASOURCE.getConnection() ;
        MyDataBaseSource.DATASOURCE.getConnection() ;
        MyDataBaseSource.DATASOURCE.getConnection() ;
    }
}
//Example 2
public enum UserActivity {
    INSTANCE;

    private DataSource _dataSource;
    private JdbcTemplate _jdbcTemplate;

    private UserActivity() {
        this._dataSource = MysqlDb.getInstance().getDataSource();
        this._jdbcTemplate = new JdbcTemplate(this._dataSource);
    }

    public void dostuff() {
     ...
    }
}

// use it as ...
UserActivity.INSTANCE.doStuff();
复制代码

Tips: 关于枚举

先看一下枚举类型的实质： 咱们定义一个表明不一样颜色的枚举类型Color，并发

public enum Color {
    RED, BLUE, GREEN;
}
复制代码

除了以上的定义方式，咱们还能够以下定义，ide

public enum Color {
    RED(), BLUE(), GREEN();
}
复制代码

到这里你就会以为迷茫（若是你是初学者的话），为何这样子也能够？其实，枚举的成员就是枚举对象，只不过他们是静态常量而已。使用 javap 命令（javap 文件名<没有后缀.class>）能够反编译 class 文件，以下函数

咱们可使用普通类来模拟枚举，下面定义一个 Color 类。

public class Color {
    private static final Color RED = new Color();
    private static final Color GREEN = new Color();
    private static final Color BLUE = new Color();
}
复制代码

对比一下，你就明白了。若是按照这个逻辑，是否还能够为其添加另外的构造方法？答案是确定的！

public enum Color {
    RED("red color", 0), BLUE("blue color", 1), GREEN("green color", 2);

    Color(String desc, int value) {
        this.desc = desc;
        this.value = value;
    }

    String desc;
    int value;
}
复制代码

为 Color 声明了两个成员变量，并为其构造带参数的构造器。若是你这样建立一个枚举

public enum Color {
    RED("red color", 0), BLUE("blue color", 1), GREEN("green color", 2);
}
复制代码

编译器就会报错，由于没有对应的构造函数。 对于类来说，最好将其成员变量私有化，而后，为成员变量提供 get、set 方法。按照这个原则，能够进一步写好 enum Color.

public enum Color {
    RED("red color", 0), BLUE("blue color", 1), GREEN("green color", 2);

    Color(String desc, int value) {
        this.desc = desc;
        this.value = value;
    }

    private String desc;
    private int value;

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }
}
复制代码

可是，java 设计 enum 的目的是提供一组常量，方便用户设计。若是咱们冒然的提供 set 方法（外界能够改变其成员属性），好像是有点违背了设计的初衷。那么，咱们应该舍弃 set 方法，保留 get 方法。

public enum Color {
    RED("red color", 0), BLUE("blue color", 1), GREEN("green color", 2);

    Color(String desc, int value) {
        this.desc = desc;
        this.value = value;
    }

    private String desc;
    private int value;

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }
}
复制代码

普通类，咱们能够将其实例化，那么，可否实例化枚举呢？在回答这个问题以前，先来看看，反编译以后的 Color.class 文件

public enum Color {
    RED("red color", 0), BLUE("blue color", 1), GREEN("green color", 2);

    private Color(String desc, int value) {
        this.desc = desc;
        this.value = value;
    }

    private String desc;
    private int value;

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }
}
复制代码

能够看出，编译器淘气的为其构造方法加上了 private，那么也就是说，咱们没法实例化枚举。全部枚举类都继承了 Enum 类的方法，包括 toString 、equals、hashcode 等方法。由于 equals、hashcode 方法是 final 的，因此不能够被枚举重写（只能够继承）。可是，能够重写 toString 方法。 那么，使用 Java 的不一样类来模拟一下枚举，大概是这个样子

public class Color {
    private static final Color RED = new Color("red color", 0);
    private static final Color GREEN = new Color("green color", 1);
    private static final Color BLUE = new Color("blue color", 2);
    private static final Color YELLOW = new Color("yellow color", 3);

    private final String _name;
    private final int _id;

    private Color(String name, int id) {
        _name = name;
        _id = id;
    }

    public String getName() {
        return _name;
    }

    public int getId() {
        return _id;
    }

    public static List<Color> values() {
        List<Color> list = new ArrayList<Color>();
        list.add(RED);
        list.add(GREEN);
        list.add(BLUE);
        list.add(YELLOW);
        return list;
    }

    @Override
    public String toString() {
        return "the color _name=" + _name + ", _id=" + _id;
    }

}
复制代码
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程