单例模式几种写法

本文摘自《多线程编程实战指南（核心篇）》

单例模式所要实现的目标（效果）非常简单：保持一个类有且仅有一个实例。出于性能的考虑，不少单例模式会采用延迟加载（Lazy Loading）的方式，即仅在需要用到相应实例的时候才创建实例。

单例模式 饿汉模式

class SingleThreadSigleton{
    private static SingleThreadSigleton instance = new SingleThreadSigleton();

    SingleThreadSigleton(){
    }

    public static SingleThreadSigleton getInstance() {
        return instance;
    }
}

单线程单例 懒汉模式

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

简单加锁实现的单例模式实现

class SingleThreadSigleton{
    private static SingleThreadSigleton instance = null;

    private SingleThreadSigleton(){
    }
    
    //静态函数加synchronized相当于synchronized(xxx.class) xxx表示当前类
    public static synchronized SingleThreadSigleton getInstance(){
        if(null == instance){
            instance = new SingleThreadSigleton();
        }
        return instance;
    }
}

基于双重检查锁定的错误单例模式实现

class SingleThreadSigleton{
    private static SingleThreadSigleton instance = null;

    private SingleThreadSigleton(){
    }
    
    public static  SingleThreadSigleton getInstance(){
        if(null == instance){
            synchronized (SingleThreadSigleton.class) {
                if(null == instance) {
                    instance = new SingleThreadSigleton();//操作1
                }
            }
        }
        return instance;
    }
}

因为需要考虑到重排序的因素，操作1可以分解为一下伪代码所示的几个独立子操作

objRef = allocate(SingleThreadSigleton.class);//分配空间
invokeConstructor(objRef);//初始化objRef引用的对象
instance = objRef;//将对象引用写入共享变量

根据重排序规则2和规则1：临界区内的操作可以在临界区内被重排序。因此上述操作可能被重排序为：子操作① -> 子操作③ -> 子操作②，这就可能导致程序出错。

基于双重检查锁定的正确单例模式实现

class SingleThreadSigleton{
    private volatile static SingleThreadSigleton instance = null;

    private SingleThreadSigleton(){
    }

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

基于静态内部类的单例模式实现

class SingleThreadSigleton{

    private SingleThreadSigleton(){
    }

    private static class InstanceHolder{
        final static SingleThreadSigleton INSTANCE = new SingleThreadSigleton();
    }

    public static SingleThreadSigleton getInstance() {
        return InstanceHolder.INSTANCE;
    }
}

基于枚举类型的单例模式实现

class EnumBasedSingletonExample{
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                SingleThreadSigleton.INSTANCE.someService();
            }
        }).start();
    }
}

enum  SingleThreadSigleton{
    INSTANCE;
    SingleThreadSigleton(){
    }
    public void someService(){
        //doSomething
    }
}

 单例模式防止反射、序列化、克隆的破坏

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Constructor;


public class Main implements Serializable, Cloneable {
    private static final long serialVersionUID = 6125990676610180062L;
    private static Main main;
    private static boolean isFristCreate = true;
    private Main(){
        /*防止反射破坏单例*/
        if(isFristCreate){
            synchronized (Main.class) {
                if(isFristCreate){
                    isFristCreate = false;
                }
            }
        }else{
            throw new RuntimeException("已经实例化一次, 不能再实例化");
        }
    }
    
    public  static Main getInstance(){
        if (main == null) {
            synchronized (Main.class) {
                if (main == null) {
                    main = new Main();
                }
            }
        }
        return main;
    }
    /*防止克隆破坏单例*/
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        return main;
    }
    /*防止序列化破坏单例*/
    private Object readResolve() {
        // TODO Auto-generated method stub
        return main;
    }
    
    
    public static void main(String[] args) throws Exception{
        Main main = Main.getInstance();
        System.out.println("singleton的hashCode:"+main.hashCode());
        //通过克隆获取
        Main clob = (Main) Main.getInstance().clone();
        System.out.println("clob的hashCode:"+clob.hashCode()); 
        //通过序列化，反序列化获取
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(Main.getInstance());
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        Main serialize = (Main) ois.readObject();
        if (ois != null) ois.close();
        if (bis != null) bis.close();
        if (oos != null) oos.close();
        if (bos != null) bos.close();
        System.out.println("serialize的hashCode:"+serialize.hashCode());
        //通过反射获取
        Constructor<Main> constructor = Main.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Main reflex = constructor.newInstance();
        System.out.println("reflex的hashCode:"+reflex.hashCode());
    }
}