单例模式学习

单例模式

1、饿汉模式

• 对象在类加载时创建，线程安全，但是浪费内存

package com.wanna.单例模式;
/**
 * 饿汉模式
 * 对象在类加载时创建
 * 线程安全，但是浪费内存
 */
public class EHan {
    private EHan(){};
    private static EHan instance=new EHan();
    public static EHan getInstance(){
        return instance;
    }
}

2、懒汉模式

• 对象在用的时候进行创建，一般线程不安全

线程不安全写法：

package com.wanna.单例模式;

/**
 * 懒汉模式
 * 对象在使用时创建 线程不安全
 */
public class LHan {
    private LHan(){};
    private static LHan instance=null;
    public static  LHan getInstance() {
        if (instance==null){
            instance=new LHan();
        }
        return instance;
    }

}

线程安全写法：区别在于是否加同步锁synchronized，但是因为加了同步锁，效率降低

package com.wanna.单例模式;

/**
 * 懒汉模式
 * 对象在使用时创建 为保证对象只有一个需要使用线程同步锁synchronized
 */
public class LHan {
    private LHan(){};
    private static LHan instance=null;
    public static synchronized LHan getInstance() {
        if (instance==null){
            instance=new LHan();
        }
        return instance;
    }
}

3、静态内部类实现

• 是对懒汉模式的优化

package com.wanna.单例模式;

/**
 * 静态内部类
 */
public class Singleton {
    private Singleton(){};
    private static class SingletonHolder{
        private static final Singleton instance=new Singleton();
    }
    public static final Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

4、双检测模式

package com.wanna.单例模式;
/**
 * 双检测模式
 */
public class DoubleCheck {
    private DoubleCheck(){};
    private static DoubleCheck instance=null;
    public static DoubleCheck getInstance() {
        if (instance==null){
            synchronized (DoubleCheck.class){
                if (instance==null){
                    instance=new DoubleCheck();
                }
            }
        }
        return instance;
    }
}