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作为类变量在初始化的过程中会被收集进()方法中,该方法能够确保同步,也就是说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进行访问,但在多线程的情况下可能会引起空指针。

原因:

7种单例模式设计_第1张图片

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编译时期收集在()中,该方法又是同步方法,可以保证内存的可见性、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();
    }
}

 

你可能感兴趣的:(Java,设计模式)