博客

单例模式介绍：


这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，**可以直接访问，不需要实例化该类的对象。**其实就是无论你调多少这对象，他就是同一个。

例如，我们在系统的多个地方需要读取一个配置文件，我们并不需要每次都去new一个实例，然后去读文件，只需要维护一个全局的Config类，并且每次使用的时候校验下文件是否变更即可。依赖可以减少类的创建跟销毁的时候的开销，二来也减少了读取文件的次数。就像spring的ioc容器。默认就是单例，节省资源， @Autowired进来的就是单例，再写service层时注意不要把mapper也注入，因为mapper是需要改的。

注意：


1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例，也就是给一个静态方法，类调用。

1、饿汉式（静态常量）

public class Single {
    private Single(){

    }
    private static final Single SINGLE=new Single();
    public static Single getInstance(){
        return SINGLE;
    }

    public static void main(String[] args) {
        Single single1 = Single.getInstance();
        Single single2 = Single.getInstance();
        System.out.println(single1);
        System.out.println(single2);
        //com.qcby.single.Single@4554617c
        //com.qcby.single.Single@4554617c
    }
}

在类装载的时候就完成实例化，可能造成内存浪费

2、饿汉式（静态代码块）

public class SingleTest {
    private SingleTest(){

    }
    private static  SingleTest SINGLE;
    static {
        SINGLE=new SingleTest();
    }
    public static SingleTest getInstance(){
        return SINGLE;
    }

    public static void main(String[] args) {
        SingleTest single1 = SingleTest.getInstance();
        SingleTest single2 = SingleTest.getInstance();
        System.out.println(single1);
        System.out.println(single2);
        //com.qcby.single.SingleTest@4554617c
        //com.qcby.single.SingleTest@4554617c
    }
}

3、懒汉式（线程不安全）

public class LazyNoSafe {
    private LazyNoSafe(){

    }
    private static LazyNoSafe lazyNoSafe;

    public static LazyNoSafe getInstance(){
        if(lazyNoSafe!=null){
            lazyNoSafe=new LazyNoSafe();
        }
        return lazyNoSafe;
    }
}

优缺点：

• 起到了懒加载的效果，但是只能在单线程下使用。
• 如果在多线程下，一个线程进入了if(singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时就会产生多个实例。所以在多线程环境下不可使用这种方式。

4、懒汉式（线程安全，同步方法）

加synchronized 关键字

public class LazyNoSafe {
    private LazyNoSafe(){

    }
    private static LazyNoSafe lazyNoSafe;

    public static synchronized LazyNoSafe getInstance(){
        if(lazyNoSafe!=null){
            lazyNoSafe=new LazyNoSafe();
        }
        return lazyNoSafe;
    }
}

优缺点：

• 解决了线程不安全问题。
• 效率太低了，每个线程在想获得类的实例的时候，执行getInstance()方法都要进行同步，而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了，方法进行同步效率太低。

5、懒汉式之双重检查（线程安全，同步代码块）

对象加上了volatile关键字是为了保证变量的可见性，防止指令重排序

public class LazySafe {
    private LazySafe(){

    }
    //对象加上了volatile关键字是为了保证变量的可见性，防止指令重排序
    //第二个线程拿到的可能是半实列化的对象，所以要加volatile防止指令重排序
    private volatile static LazySafe lazySafe;

    public static  LazySafe getInstance(){
        if(lazySafe!=null){
            //双重判定
            synchronized (LazySafe.class){
                if(lazySafe!=null){
                    lazySafe=new LazySafe();
                }
            }
        }
        return lazySafe;
    }
}

6、静态内部类

public class StaticClass {
    private StaticClass(){

    }

    private static class Inner{
        private static final StaticClass STATIC_CLASS=new StaticClass();
    }
    public static StaticClass getInstance(){
        return Inner.STATIC_CLASS;
    }

}

7、枚举

public class SingletonEnum {
    public static void main(String[] args) {
        SingletonEnumDemo.INSTANCE.doSomething();
    }
}
enum  SingletonEnumDemo{
    INSTANCE;
    public void doSomething(){
        //逻辑
    }
}

在jdk源码中哪有体现

Runtime 类采用了饿汉式

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }
    
    /** Don't let anyone else instantiate this class */
    private Runtime() {}
    。。。。。。
}

单例模式注意事项和细节说明

1)单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能

2)当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new

3)单例模式使用的场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即:重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)