Note when going straight for success of Mr.Wang

0%

单例模式

发表于 更新于 分类于

设计模式之单例模式

定义

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

了解

  单例模式有三个要点：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

结构图

单例模式是结构最简单的设计模式一，在它的核心结构中只包含一个被称为单例类的特殊类
alt
Singleton（单例）：在单例类的内部实现只生成一个实例，同时它提供一个静态的getInstance()工厂方法，让客户可以访问它的唯一实例；为了防止在外部对其实例化，将其构造函数设计为私有；在单例类内部定义了一个Singleton类型的静态对象，作为外部共享的唯一实例。

示例

alt

饿汉式单例与懒汉式单例

饿汉式

alt

1
2
3
4
5
6
7
8
class EagerSingleton { 
    private static final EagerSingleton instance = new EagerSingleton(); 
    private EagerSingleton() { } 
 
    public static EagerSingleton getInstance() {
        return instance; 
    }   
}

  当类被加载时，静态变量instance会被初始化，此时类的私有构造函数会被调用，单例类的唯一实例将被创建。如果使用饿汉式单例来实现负载均衡器LoadBalancer类的设计，则不会出现创建多个单例对象的情况，可确保单例对象的唯一性。

懒汉式

alt
  懒汉式单例在第一次调用getInstance()方法时实例化，在类加载时并不自行实例化，这种技术又称为延迟加载(Lazy Load)技术
避免多线程环境下出现问题（实例化多个对象）:

  • synchronized关键字：可加在类上，也可加在判空后的初始化对象方法上，后者效率更高
  • 双重检查锁定(Double-Check Locking)
  • volatile修饰符：被volatile修饰的成员变量可以确保多个线程都能够正确处理，但volatile关键字会屏蔽Java虚拟机所做的一些代码优化，可能会导致系统运行效率降低
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class LazySingleton { 
    private volatile static LazySingleton instance = null; 
 
    private LazySingleton() { } 
 
    public static LazySingleton getInstance() { 
        //第一重判断
        if (instance == null) {
            //锁定代码块
            synchronized (LazySingleton.class) {
                //第二重判断
                if (instance == null) {
                    instance = new LazySingleton(); //创建单例实例
                }
            }
        }
        return instance; 
    }
}

比较

  1.   饿汉式单例类在类被加载时就将自己实例化，它的优点在于无须考虑多线程访问问题，可以确保实例的唯一性；从调用速度和反应时间角度来讲，由于单例对象一开始就得以创建，因此要优于懒汉式单例。但是无论系统在运行时是否需要使用该单例对象，由于在类加载时该对象就需要创建，因此从资源利用效率角度来讲，饿汉式单例不及懒汉式单例，而且在系统加载时由于需要创建饿汉式单例对象，加载时间可能会比较长。
  2.   懒汉式单例类在第一次使用时创建，无须一直占用系统资源，实现了延迟加载，但是必须处理好多个线程同时访问的问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费大量时间，这意味着出现多线程同时首次引用此类的机率变得较大，需要通过双重检查锁定等机制进行控制，这将导致系统性能受到一定影响。

Initialization Demand Holder (IoDH)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//Initialization on Demand Holder
class Singleton {
	private Singleton() {
	}
	
	private static class HolderClass {
            private final static Singleton instance = new Singleton();
	}
	
	public static Singleton getInstance() {
	    return HolderClass.instance;
	}
	
	public static void main(String args[]) {
	    Singleton s1, s2; 
            s1 = Singleton.getInstance();
	    s2 = Singleton.getInstance();
	    System.out.println(s1==s2);
	}
}

  在IoDH中，我们在单例类中增加一个静态(static)内部类，在该内部类中创建单例对象，再将该单例对象通过getInstance()方法返回给外部使用
  由于静态单例对象没有作为Singleton的成员变量直接实例化，因此类加载时不会实例化Singleton，第一次调用getInstance()时将加载内部类HolderClass，在该内部类中定义了一个static类型的变量instance，此时会首先初始化这个成员变量，由Java虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于getInstance()方法没有任何线程锁定，因此其性能不会造成任何影响。
  通过使用IoDH，我们既可以实现延迟加载，又可以保证线程安全，不影响系统性能，不失为一种最好的Java语言单例模式实现方式，但是其与编程语言本身的特性相关，很多面向对象语言不支持IoDH。

总结

  单例模式作为一种目标明确、结构简单、理解容易的设计模式，在软件开发中使用频率相当高，在很多应用软件和框架中都得以广泛应用。

优点

  1. 单例模式提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它。
  2. 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
  3. 允许可变数目的实例。基于单例模式我们可以进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例，既节省系统资源，又解决了单例单例对象共享过多有损性能的问题。

缺点

  1. 由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
  2. 单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。
  3. 现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的共享对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致共享的单例对象状态的丢失。

适用场景

  1. 系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。
  2. 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。

code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
import javax.xml.crypto.dsig.spec.DigestMethodParameterSpec;
import java.util.*;

/**
 * @author Wangzy
 * @Description: 负载均衡器
 * @date 17:01 2019/12/25
 */
public class LoadBalancer {

    // 饿汉式单例模式
//    private static final LoadBalancer loadBalancer = new LoadBalancer();

    /**
     * @Description: （懒汉式单例模式）静态变量引用 volatile 关键字保证确保多个线程都能够正确处理，但volatile关键字会屏蔽Java虚拟机所做的一些代码优化，可能会导致系统运行效率降低
     * @author Wangzy
     * @date 17:53 2019/12/25
     */
//    private volatile static LoadBalancer loadBalancer = null;

    /** 各个服务器集合 */
    private List<String> serverList;

    /**
     * @Description: 私有构造方法
     * @author Wangzy
     * @date 17:02 2019/12/25
     */
    private LoadBalancer() {
        // 默认负载均衡器自带服务器容器
       serverList = new ArrayList<>();
    }

    /**
     * @Description: 提供整个系统的实例化对象方法  加锁和双重检查锁定都是为了解决多线程产生的问题
     * @author Wangzy
     * @date 17:04 2019/12/25
     */
//    public static LoadBalancer getInstance() {
////        if (null == loadBalancer) {
////            // 加锁
////            synchronized (LoadBalancer.class) {
////                // 双重检查锁定
////                if (null == loadBalancer) {
////                    loadBalancer = new LoadBalancer();
////                }
////            }
////        }
////        return loadBalancer;
////    }

    /**
     * @Description: IoDH  要实例化的类不会加载此类；jvm会自动优化线程问题；效率最高，但受语言限制
     * @author Wangzy
     * @date 18:05 2019/12/25
     */
    private static class ClassHolder {
        private static final LoadBalancer loadBalancer = new LoadBalancer();
    }

    public static LoadBalancer getInstance() {
        return ClassHolder.loadBalancer;
    }

    /**
     * @Description: 添加服务器
     * @author Wangzy
     * @date 17:06 2019/12/25
     */
    public void addServer(String server) {
        serverList.add(server);
    }

    /**
     * @Description: 移除服务器
     * @author Wangzy
     * @date 17:06 2019/12/25
     */
    public void removeServer(String server) {
        serverList.remove(server);
    }

    /**
     * @Description: 查询服务器(负载均衡实现，随机算法)
     * @author Wangzy
     * @date 17:06 2019/12/25
     */
    public String getServer() {
        List<String> serverList = this.serverList;
        Random random = new Random();
        int i = random.nextInt(serverList.size());
        return serverList.get(i);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
 * @author Wangzy
 * @Description: 启动类
 * @date 17:12 2019/12/25
 */
public class Boot {

    public static void main(String[] args) {
        // 获取负载均衡服务器（模拟多个用户共享一个实例）
        LoadBalancer loadBalancer = LoadBalancer.getInstance();
        LoadBalancer loadBalancer1 = LoadBalancer.getInstance();
        LoadBalancer loadBalancer2 = LoadBalancer.getInstance();
        // 判断是否是同一个负载均衡器(是否获取的是同一个实例)
        if (loadBalancer == loadBalancer1 && loadBalancer1 == loadBalancer2) {
            System.out.println("服务器负载均衡器具有唯一性！");
        }
        // 给负载均衡服务器添加服务器
        loadBalancer.addServer("server1");
        loadBalancer.addServer("server2");
        loadBalancer.addServer("server3");
        // 模拟客户端请求分发
        for (int i = 1; i < 10; i++) {
            System.out.println("分发请求至服务器" + loadBalancer.getServer() + "服务器!");
        }

    }
}

相关资料

https://blog.csdn.net/lovelion/article/details/7420883
https://blog.csdn.net/lovelion/article/details/7420885
https://blog.csdn.net/lovelion/article/details/9319423
https://blog.csdn.net/lovelion/article/details/7420888
https://blog.csdn.net/lovelion/article/details/7420889

-------------the end-------------