7种单例模式设计

阅读《Java高并发编程详解》后的笔记。

1、饿汉式：

/**
 * 饿汉式
 * 若一个类的成员都是比较重的资源，这种方式不合适
 */
//不允许被继承
public final class Singleton {

    //定义实例变量的时候直接初始化
    //instance被ClassLoader 加载后很长一段时间才被使用，它所开辟的堆内存会驻留更久
    private static Singleton instance = new Singleton();

    //私有构造函数，不允许外部new
    private Singleton(){

    }

    //无法进行懒加载
    public static Singleton getInstance(){
        return instance;
    }
}

以上代码中instance作为类变量在初始化的过程中会被收集进<clinit>()方法中，该方法能够确保同步，也就是说instance在多线程的情况下不可能被实例化两次，只是instance被ClassLoader 加载后很长一段时间才被使用，instance实例所开辟的堆内存会驻留更久。饿汉式的单例设计模式可以保证多个线程下的唯一实例。

2、懒汉式：

/**
 * 懒汉式
 * 实用类实例变量的时候再去创建
 */
public final class Singleton {

    //定义实例,不初始化
    private static Singleton instance = null;

    //私有构造函数，不允许外部new
    private Singleton(){

    }

    //可保证实例的懒加载，但无法保证实例的唯一性
    public static Singleton getInstance(){
        if(null == instance)
            instance = new Singleton();
        return instance;
    }
}

以上代码中Singleton.class被初始化时instance并没有被实例化，getInstance()会判断instance是否被实例化，但是放在多线程的环境下进行分析，若有两个线程同时看到instance为null，那么instance将无法保证单例的唯一性。

3、懒汉式+同步方法


/**
 * 懒汉式+同步方法
 * 
 */
public final class Singleton {

    //定义实例,不初始化
    private static Singleton instance = null;

    //私有构造函数，不允许外部new
    private Singleton(){

    }

    //向getInstance()加入同步控制，每次只能有一个线程进入
    public static synchronized Singleton getInstance(){
        if(null == instance)
            instance = new Singleton();
        return instance;
    }
}

这里instance其实就是共享资源（数据），当多个线程访问时，需要保证数据的同步性，这种方式满足了懒加载又能保证instance实例的唯一性，但是synchronized的排他性导致getInstance()只能在同一时刻被一个线程访问，性能地下。

4、Double-Check

/**
 * Double-Check
 * 高效的数据同步策略，首次初始化时加锁，之后允许多个线程同时进行getInstance调用来获得实例
 */
public final class Singleton {

    //定义实例,不初始化
    private static Singleton instance = null;

    Connection conn;

    Socket socket;

    //私有构造函数，不允许外部new
    private Singleton(){
        this.conn;//初始化conn
        this.socket;//初始化socket
    }

    public static Singleton getInstance(){
        //当instance为null时，进入同步代码块，同时可避免了每次都需要进入同步代码块，可提高效率
        if(null == instance) {
            synchronized (Singleton.class){
                //判断如果instance为null时创建
                if(null == instance){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

当有两个线程发现null==instance成立时，只有一个线程有资格进入同步代码块，完成对instance的实例化，随后的线程发现null==instance不成立则不进行任何动作，以后对getInstance的访问就不需要数据同步保护了。

这种方法既满足了懒加载，又保证了instance实例的唯一性，可以允许多个线程同时对getInstance进行访问，但在多线程的情况下可能会引起空指针。

原因：

扫描二维码关注公众号，回复： 5113646 查看本文章

5、volatile+Double-Check

/**
 * volatile+Double-Check
 * 高效的数据同步策略,volatile可以防止指令重排序
 */
public final class Singleton {

    //定义实例,不初始化
    private volatile static Singleton instance = null;

    //私有构造函数，不允许外部new
    private Singleton(){

    }

    public static Singleton getInstance(){
        //当instance为null时，进入同步代码块，同时可避免了每次都需要进入同步代码块，可提高效率
        if(null == instance) {
            synchronized (Singleton.class){
                //判断如果instance为null时创建
                if(null == instance){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

这种方式满足多线程下的单例、懒加载以及获取实例的高效性。

6、Holder方式

/**
 * Holder方式
 * 借助类加载的特点，单例设计的最好方式之一
 */
public final class Singleton {

    //私有构造函数，不允许外部new
    private Singleton(){

    }

    //在静态内部类中持有Singleton的实例，并且可直接被初始化
    private static class Holder{
        
        private static  Singleton instance = new Singleton();
    }
    
    //调用getInstance方法，事实上获得Holder的instance静态属性
    public static Singleton getInstance(){
        return Holder.instance;
    }
}

在Singleton初始化的过程中不会创建Singleton的实例，静态内部类Holder中定义了Singleton的静态变量，并直接实例化，当Holder被主动引用时会创建Singleton的实例，Singleton实例的创建在Java编译时期收集在<clinit>()中，该方法又是同步方法，可以保证内存的可见性、JVM指令的顺序性以及原子性。

7、枚举方式

/**
 * 枚举方式
 * 枚举类型不允许被继承，同时是线程安全且只能被实例化一次
 * 
 */
public enum Singleton {

    INSTANCE;
    
    Singleton(){
        System.out.println("INSTANCE will be initialized immediately");
    }

    private static void method(){

       //调用该方法会主动使用Singleton,INSTANCE将会被实例化
    }

    //调用getInstance方法，事实上获得Holder的instance静态属性
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

枚举类型不允许被继承，同时是线程安全且只能被实例化一次，但是枚举类型不能够懒加载，对Singleton主动使用，如滴啊用其中的静态方法INSTANCE会立即实例化，可对其进行改造，增加懒加载的特性，类似于Holder方式：

/**
 * 类似于Holder方式
 * 枚举类型不允许被继承，同时是线程安全且只能被实例化一次
 *
 */

public class Singleton{

    private Singleton(){

    }

    //使用枚举充当holder
    private enum EnumHolder {

        INSTANCE;

        private Singleton instance;

        EnumHolder(){
            this.instance = new Singleton();
        }

        public Singleton getSingleton(){
            return instance;
        }
    }

    public static Singleton getInstance(){
        return EnumHolder.INSTANCE.getSingleton();
    }
}

猜你喜欢