设计模式——单例模式

一、介绍

    单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。即一个类只有一个对象实例。

二、特点

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

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

    3、单例类必须给所有其他对象提供这一实例。

三、优点

    1、在内存中只有一个实例，节省内存。

    2、避免了频繁的创建和销毁，提高了性能。

    3、避免对共享资源的多重占用。

四、缺点

    1、扩展困难。

    2、单例类职责过重，违背了单一功能原则。

五、适用场景

    1、需要频繁创建销毁的对象。

    2、创建对象时耗时过多或者耗资源过多，但又经常用到的对象。

    3、资源互相通信时。

六、实现的方式

    1、饿汉式

public class Hunger {

    private static final Hunger hunger = new Hunger();

    private Hunger(){};

    public static final Hunger getInstance(){
        return hunger;
    }
}

        这种方式是线程安全的，但是缺点就是占用资源，不管用不用它，该实例已经存在了。

    2、懒汉式

public class LazyOne {

    private static LazyOne lazyOne = null;

    private LazyOne(){};

    public static final LazyOne getInstance(){
        if (lazyOne == null){
            lazyOne = new LazyOne();
        }
        return lazyOne;
    }
}

        这种方式是线程不安全的，不推荐使用。

public class LazyTwo {

    private static LazyTwo lazyTwo = null;

    private LazyTwo(){}

    public static synchronized final LazyTwo getInstance(){
        if(lazyTwo == null){
            lazyTwo = new LazyTwo();
        }
        return lazyTwo;
    }
}

        这种方式是线程安全的，但是加了同步锁之后执行效率比较低。

public class LazyThree {

    private static volatile LazyThree lazyThree = null;

    private LazyThree(){};

    public static LazyThree getInstance(){
        if(lazyThree == null){
            synchronized(LazyThree.class){
                if(lazyThree == null){
                    lazyThree = new LazyThree();
                }
            }
        }
        return lazyThree;
    }
}

        这种方式是线程安全的，比上面执行效率提高很多。

public class LazyFour {

   private LazyFour(){};

   public static final LazyFour getInstance(){
       return LazyFourInner.lazyFour;
   }

   private static class LazyFourInner{
       private static final LazyFour lazyFour = new LazyFour();
   }
}

         这种方式是线程安全的，推荐使用这种写法。