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