设计模式（3）-单例模式

最新推荐文章于 2024-08-22 09:12:59 发布

潘威威

最新推荐文章于 2024-08-22 09:12:59 发布

阅读量1.3k

点赞数 1

分类专栏： 24种设计模式文章标签：设计模式 design-patterns 单例模式 singleton 对象结构型模式

本文链接：https://blog.csdn.net/panweiwei1994/article/details/72821969

版权

设计模式同时被 2 个专栏收录

32 篇文章 3 订阅

订阅专栏

24种设计模式

31 篇文章 20 订阅

订阅专栏

简介

什么时候使用单例模式

对于一个类来说，如果创建了两个对象或更多对象，程序会出错。
需要频繁实例化然后销毁的对象。
创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
有状态的工具类对象。
频繁访问数据库或文件的对象。

什么是单例模式

单例模式(Singleton Pattern)：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。

类型：

对象创建型模式

要点

只能有一个实例。
必须自己创建自己的唯一实例。
必须给整个系统提供这一实例。

从具体实现角度来说，就是以下三点：

单例模式的类只提供私有的构造函数。
类定义中含有一个该类的静态私有对象。
该类提供了一个静态的公有的函数用于创建或获取它本身的静态私有对象。

实现

测试是否能实现单例模式的工具类

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestSingleton {

    public static void main(String[] args) throws InterruptedException {

        final Set<String> set = Collections.synchronizedSet(new HashSet<String>());
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 1000; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    Singleton singleton = Singleton.getInstance();
                    set.add(singleton.toString());
                }
            });
        }
        Thread.sleep(5000);
        System.out.println("一共创建了" + set.size() + "个实例");
        for (String str : set) {
            System.out.println(str);
        }
        executor.shutdown();
    }
}

懒汉式-线程不安全

描述：这种实现最大的问题就是不支持多线程，所以严格意义上它并不算单例模式。
是否多线程安全：否
优点：

避免了饿汉式的那种在没有用到的情况下创建事例，资源利用率高，不执行getInstance()就不会被实例，可以执行该类的其他静态方法。

缺点：

不支持多线程

代码实例：

public class Singleton {  
    private static Singleton instance;  

    private Singleton (){}  

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

测试是否支持多线程

执行TestSingleton .java的main()方法几次，观察结果，发现确实不支持多线程。

懒汉式-线程安全

描述：支持多线程，但效率低
是否多线程安全：是
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
代码实例：

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

测试是否支持多线程

执行TestSingleton .java的main()几次，测试并观察结果，发现确实支持多线程。

饿汉式

描述：支持多线程，这种方式比较常用，但容易产生垃圾对象。
是否多线程安全：是
优点

没有加锁，执行效率会提高。
在类加载的同时已经创建好一个静态对象，调用时反应速度快。

缺点

类加载时就初始化，浪费内存。

代码实例：

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

测试是否支持多线程

执行TestSingleton .java的main()几次
测试并观察结果，发现确实支持多线程

双检锁/双重校验锁（DCL，即 double-checked locking）

描述：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。getInstance() 的性能对应用程序很关键。
是否多线程安全：是
优点：资源利用率高，不执行getInstance()就不被实例，可以执行该类其他静态方法
缺点：第一次加载时反应不快，由于java内存模型一些原因偶尔失败
代码实例：

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getInstance() {  
        if (singleton == null) {  
            synchronized (Singleton.class) {  
                if (singleton == null) {  
                    singleton = new Singleton();  
                }  
            }  
        }  
        return singleton;  
    }  
}

测试是否支持多线程

执行TestSingleton .java的main()几次，测试并观察结果，发现确实支持多线程

登记式/静态内部类

描述：这种方式能达到双检锁方式一样的功效，但实现更简单。
是否多线程安全：是
优点：资源利用率高，不执行getInstance()不被实例，可以执行该类其他静态方法。
缺点：第一次加载时反应不够快。
代码实例：

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

测试是否支持多线程

执行TestSingleton .java的main()几次，测试并观察结果，发现确实支持多线程。

枚举

描述：这种实现方式还没有被广泛采用，但据说这是实现单例模式的最佳方法。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式。
是否多线程安全：是
优点：它更简洁，不仅能避免多线程同步问题，而且还自动支持序列化机制。
缺点：枚举是JDK1.5以后才支持的。
代码实例：

class Resource{
}

public enum Singleton{
    INSTANCE;
    private Resource instance;
    Singleton() {
        instance = new Resource();
    }
    public Resource getInstance() {
        return instance;
    }
}

上面的类Resource是需要应用单例模式的资源，具体可以表现为网络连接，数据库连接，线程池等等。
获取资源的方式很简单，只要 Singleton.INSTANCE.getInstance() 即可获得所要实例。

测试是否支持多线程

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestSingleton {

    public static void main(String[] args) throws InterruptedException {

        final Set<String> set = Collections.synchronizedSet(new HashSet<String>());
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 1000; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    Resource singleton = Singleton.INSTANCE.getInstance();
                    set.add(singleton.toString());
                }
            });
        }
        Thread.sleep(1000);
        System.out.println("一共创建了" + set.size() + "个实例");
        for (String str : set) {
            System.out.println(str);
        }
        executor.shutdown();
    }
}

执行TestSingleton .java的main()几次
测试并观察结果，发现确实支持多线程

总结

单例模式各种实现方法的优缺点

详见每种单例实现的介绍

优点

只能创建一个对象，节省内存空间。
避免频繁的创建销毁对象，可以提高性能。
避免对共享资源的多重占用。
可以全局访问。

缺点

扩展困难，因为单例模式没有抽象层。
职责过重，在一定程度上违背了“单一职责原则”。
滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

注意事项
- 使用时不能用反射模式创建单例，否则会实例化一个新的对象。
- 使用懒单例模式时注意线程安全问题。
- 饿单例模式和懒单例模式构造方法都是私有的，因而是不能被继承的，有些单例模式可以被继承（如登记式单例模式）。

饿汉式单例和懒汉式单例的不同

Tables	饿汉式单例	懒汉式单例
实例化对象时机	单例类被加载时候	调用实例方法时
是否支持多线程	支持	需要加synchronized
反应时间	快	慢
资源利用率	低	高
延迟加载	否	是