Java设计模式之单例模式的七种写法

什么是单例模式？

单例模式是一种常见的设计模式，单例模式的写法有很多种，这里主要介绍三种： 懒汉式单例模式、饿汉式单例模式、登记式单例 。

单例模式有以下特点：

1、单例类只能有一个实例。

2、单例类必须自己创建自己唯一的实例。

3、单例类必须给所有其它对象提供这一实例。

单例模式确保某各类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能，每台计算机可以有若干个打印机，但只能有一个Printer spooler，以避免两个打印作业同时输出到打印机中，每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态.

在将单例之前，要做一次基础知识的科普行动，大家都知道Java类加载器加载内容的顺序：

1、从上往下(Java的变量需要声明才能使用)

2、先静态后动态(对象实例化) （静态块和static关键字修饰在实例化以前分配内存空间）

3、先属性后方法（成员变量不能定义在方法中，只能定义在class下）

懒汉式单例(4种写法)

懒汉式顾名思义：需要用到的时候才会初始化

饿汉式：不管用不用先实例化

注册登记式：相当于有一个容器装载实例，在实例产生之前会先检查一下容器看有没有，如果有就直接取出来使用，如果没有就先new一个放进去，然后在后面的人使用，Spring IOC就是一种典型的注册登记单例

第一种写法：

/**
* Created by xingyuchao on 2018/1/20.
* 懒汉式单例类，在第一次使用的时候实例化自己
*/
public class Singleton {

//1.第一步先将构造方法私有化
private Singleton(){}

//2.然后声明一个静态变量保存单例的引用
private static Singleton single = null;

//3.通过提供一个静态方法来获得单例的引用
public static Singleton getInstance(){
if(single == null){
single = new Singleton();
}
return single;
}
}

Singleton1通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Signleton1的唯一实例只能通过getInstance（）方法访问。

事实上，通过Java反射机制是能否实现实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效，此问题在此处不做讨论

但是以上懒汉式单例的实现没有考虑线程安全问题，它是非线程安全的，并发环境下可能出现多个Singleton1实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法的改造，保证了懒汉式单例的线程安全.

第二种写法：在getInstance()方法上加同步

/**
* Created by xingyuchao on 2018/1/29.
* 懒汉式单例类,保证线程安全
*/
public class Singleton2 {

//1.第一步先将构造方法私有化
private Singleton2(){}

//2.然后声明一个静态变量保存单例的引用
private static Singleton2 single = null;

//3.通过提供一个静态方法来获得单例的引用
// 为了保证线程环境下正确访问，给方法上加上同步锁synchronized
public static synchronized Singleton2 getInstance(){
if(single == null){
single = new Singleton2();
}
return single;
}
}

第三种写法：双重检测机制

/**
* Created by xingyuchao on 2018/1/29.
* 懒汉式单例类,保证线程安全  双重检测机制
*/
public class Singleton3 {

//1.第一步先将构造方法私有化
private Singleton3(){}

//2.然后声明一个静态变量保存单例的引用
private static Singleton3 single = null;

//3.通过提供一个静态方法来获得单例的引用
// 为了保证线程环境下的另一种实现方式，双重锁检查
public static synchronized Singleton3 getInstance(){
if(single == null){
single = new Singleton3();
}
return single;
}
}

第四种：静态内部类

/**
* Created by xingyuchao on 2018/1/29.
* 懒汉式单例类,通过静态内部类实现
*/
public class Singleton4 {

//1. 先声明一个静态内部类
//内部类的初始化，需要依赖主类
//也就是说，当JVM加载Singleton4类的时候LazyHolder类也会被加载
//只是目前还没有被实例化，需要等主类先实例化后，内部类才开始实例化
private static class LazyHolder{
//final是为了防止内部类将这个属性值覆盖掉
private static final Singleton4 INSTANCE = new Singleton4();
}

//2. 将默认构造方法私有化
private Singleton4(){}

//3.同样提供静态方法获取实例

//当getInstance方法第一次被调用的时候，它第一次读取LazyHolder.INSTANCE，内部类LazyHolder类得到初始化；
// 而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton4的实例，由于是静态的域，因此只会在
// 虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。这个模式的优势在于，getInstance方法并没有被同步，
// 并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本。

//此处加final是为了防止子类重写父类方法
public static final Singleton4 getInstance(){
return LazyHolder.INSTANCE;
}
}

饿汉式单例(1种写法)

/**
* Created by xingyuchao on 2018/1/29.
* 饿汉式单例类，在类初始化时，已经自行初始化，不会产生线程安全问题
*/
public class Singleton5 {

//1.同样也是将默认构造方法私有化
private Singleton5(){}

//2.声明静态变量，在类初始化之前就初始化变量，将对象引用保存
//相反的如果这个单例对象一直没使用，那么内存空间也就被浪费掉了
private static final Singleton5 singleton = new Singleton5();

//3.开放静态方法，获取实例
public static Singleton5 getSingleton(){
return singleton;
}

}

枚举式单例(1种写法)

public class DBConnection {}

/**
* Created by xingyuchao on 2018/1/29.
* 枚举式单例
*/
public enum Singleton6 {

DATASOURCE;

private DBConnection connection = null;

private Singleton6() {
connection = new DBConnection();
}

public DBConnection getConnection() {
return connection;
}
}

/**
* Created by xingyuchao on 2018/1/29.
*/
public class Main {

public static void main(String[] args) {
DBConnection dbConnection1 = Singleton6.DATASOURCE.getConnection();

DBConnection dbConnection2 = Singleton6.DATASOURCE.getConnection();

System.out.println(dbConnection1 == dbConnection2); //true true  结果表明两次获取返回了相同的实例。
}
}

这种方式不仅能避免多线程同步问题，而且能防止反射创建新的对象，可谓是很坚强的壁垒不过这种方式用的极少

为什么枚举会满足线程安全、序列化等标准。参考：http://blog.csdn.net/gavin_dyson/article/details/70832185

登记注册式单例

/**
* Created by xingyuchao on 2018/1/29.
* 登记式单例：类似spring里面的方法，将类名注册，下次直接从里面获取
*
* 登记式单例实际上维护了一组单例类的实例，将这些实例存放在一个Map(登记簿)中，对于已经登记过的实例，则从Map直接获取，对于没有登记的，则先登记，然后返回
*
* 内部实现还是用的饿汉式单例，因为其中的static方法块，它的单例在被装载的时候就被实例化了
*/
public class Singleton7 {

private static Map<String,Singleton7> map = new HashMap<>();

static{
Singleton7 singleton7 = new Singleton7();
map.put(singleton7.getClass().getName(),singleton7);
}

//保护的默认构造
protected Singleton7(){}

//静态工程方法，返回此类的唯一实例
public static Singleton7 getInstance(String name) throws Exception {
if(name == null){
name = Singleton7.class.getName();
}

if(map.get(name) == null){
map.put(name,(Singleton7)Class.forName(name).newInstance());
}

return map.get(name);
}
}

测试：

public class Test {

public static void main(String[] args) throws Exception{
//启动100个线程同时去抢占cpu ，有可能产生并发，观察并发情况下是否为同一个对象实例
int count = 100;

//发令枪
CountDownLatch latch = new CountDownLatch(count);

for (int i = 0; i < count; i++){
//Lambda简化后
new Thread(()->{
System.out.println(System.currentTimeMillis() + ":" + Singleton4.getInstance());
}).start();

latch.countDown();
}

latch.await(); //开始法令，抢占cpu
}

}

结果：

分布式环境下的单例

有两个问题需要注意：

1. 如果单例类由不同的类装载器装载，那边可能存在多个单例类的实例。假定不是远端存取，例如有一些servlet容器对每个servlet使用完全不同的类装载器，这样的话如果有两个servlet访问一个单例类，它们就会有各自的实例

解决：指定classloader

private static Class getClass(String classname) throws ClassNotFoundException{
ClassLoader classloader = Thread.currentThread().getContextClassLoader();

if(classloader == null){
classloader = Singleton.class.getClassLoader();
}

return (classloader.loadClass(classname));
}

2. 如果Singleton实现了java.io.Serializable接口，那么这个类的实例就可能被序列化和复原。不管怎么样，如果你序列化一个单例类的对象，接下来复原多个那个对象，那么就会有多个类的实例

public class Singleton implements Serializable {

public static Singleton singleton = new Singleton();

protected Singleton(){}

private Object readResolve(){
return singleton;
}
}