单例模式

单例模式的本质

保证一个类在内存中的对象唯一性。

一、应用场景

常常也用于 IO 、数据库的连接、Redis 连接等，对象实例只有一个，不需要频繁地创建和销毁对象，浪费系统资源；没必要创建一模一样的对象。

比如：

a.多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。

b.Runtime()方法就是单例设计模式进行设计的。

二、如何保证对象唯一性呢？

a.类图

1.用私有静态变量 instance 将实例保存起来；

2.调用 getInstance() 时直接返回 instance 变量。

b.思想：

1，不让其他程序创建该类对象。

2，在本类中创建一个本类对象。

3，对外提供方法，让其他程序获取这个对象。

c.步骤：

1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象；

2，就在类中创建一个本类的对象；

3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控）

d.代码体现：

1，私有化构造函数；

2，创建私有并静态的本类对象；

3，定义公有并静态的方法，返回该对象。

三、代码示例

a.懒汉式:延迟加载方式

class Single1{

    private Single1(){}

    private static Single1 s = null;

    public static Single1 getInstance(){

        if(s==null)

        s = new Single1();

        return s;
    }

}

以上示例看起来很简单，但是，当在多线程调用 getInstance() 方法时，就会有线程安全的问题，所以这不是真正的单例，因此有以下的方案：

b.使用 synchronized 关键字给 getInstance() 加上锁

class Single2{

    private Single2(){}

    private static Single2 s = null;

    public static sychronized Single2 getInstance(){

        if(s==null)

        s = new Single2();

        return s;
    }

}

由于加了锁，多个线程同时调用getInstance()方法时，只能是一个线程进入，其它线程必须等待进入的线程出来后才能进入，这时是同步阻塞的方式，保证 s变量实例是唯一的，这才是真正的单例。但是这样加了锁，造成性能损耗的问题，还是不太好。

另外，前面两种方式单例模式都是在调用getInstance() 方法时才创建实例，即“ 懒汉式 ”。

那有没有更好的解决办法呢？有，思路就是只要在线程第一次调用时加锁，之后并不需要锁，因为锁给带来了系统资源浪费。请往下看：

c.饿汉式：非延迟加载方式

class Single3{

    private Single3(){} //私有化构造函数。

    private static Single3 s = new Single3(); //创建私有并静态的本类对象。
    // private static final Single3 s = new Single3();

    public static Single3 getInstance(){ //定义公有并静态的方法，返回该对象。

        return s;

    }

}

上面这样饿汉式就可以保住实例的唯一性。并且，在类初始化（类转载）时就完成实例化，避免了线程问题。如果从始至终从未使用过这个实例，就会造成内存的浪费，一直占用着内存资源。

另外，还有一种是“双重检查加锁”的方式，即是使用volatile和synchronized关键字，利用valatile关键字修饰的变量所引用的内存共享特性，即可见性。以及synchronized关键字的互斥性、可重入锁性来做“双重检查加锁”单例。如下示例：

d.双重检查加锁

class Single4{

    private Single4(){} //私有化构造函数。

    private static volatile Single4 s; //创建私有并静态可见性的本类对象变量

    public static Single4 getInstance(){ //定义公有并静态的方法，返回该对象。

        if(s == null){
            synchronized(Single4.class){
                s = new Single4();
            }            
        }

        return s;

    }

}

这种方式，可以减少锁带来性能的损耗。也就是只要在线程第一次调用时加锁，之后并不需要锁，直接返回第一次实例化的对象实例了。

四、综上所述

一般情况下使用单例模式的饿汉式（非延迟加载方式），如特殊要求，使用双重检查加锁的方式。

对于单例饿汉式是预先创建（初始化）好对象实例了，就这一次，自然不会出现更多实例。

而懒汉式调用时再创建，在不加同步锁的情况下，可能同时有多个线程请求，就创建多个实例了。

多线程主要是利用CPU的进程的线程，而内存则是发生线程冲突的地方，内存就是放对象的地方。所谓线程不安全，就是线程破坏了数据的特性。

当然实现单例模式有很多种实现方法或写法，比如用枚举，静态块，原理都是一样：保证只创建一个实例对象（保证一个类在内存中的对象唯一性）。

 

the end.

-------------------------------------------------------------------------------------------------------------