设计模式之单例模式

单例模式

(单例模式)

定义

==单例模式==确保一个类只有一个实例，并提供一个全局访问点。

单例模式实现的方式

1. 饿汉式

public class Hungry {

    //构造器私有
    private Hungry(){
    }
    //类加载时就初始化，主动创建
    private static Hungry hungry = new Hungry();

    public static Hungry getInstance(){
        return hungry;
    }
}

注：避免了线程同步问题，但没有达到懒加载效果，造成内存的浪费。

2. 懒汉式，线程不安全

public class LazyMan {

    private LazyMan(){
    }
    //不主动创建实例，等需要的时候再创建
    private static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if (lazyMan == null){
             lazyMan = new LazyMan();
        }
        return lazyMan;
    }
}

注：单线程下是可行的，但是多线程并行调用getInstance()的时候会创建多个实例。

3. 懒汉式，线程安全

public class LazyMan {

    private LazyMan(){}
    //不主动创建实例，等需要的时候再创建
    private static LazyMan lazyMan;

    public static synchronized LazyMan getInstance(){
        if (lazyMan == null){
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }
}

注：使用synchronized修饰符，避免线程同步问题，但是性能较差。

4. 双重检验锁模式

public class LazyMan {

    private LazyMan(){}
    //不主动创建实例，等需要的时候再创建
    private volatile static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if (lazyMan == null){                   //第一次检查
            synchronized(LazyMan.class){
                if (lazyMan == null){           //第二次检查
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }
}

注：使用同步块加锁的方式。如果第一次检查instance不为null，那就不需要执行下面的加锁和初始化操作。因此，可以大幅降低synchronized带来的性能开销。