[Java知识库]java设计模式之单例模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。

（1）饿汉式（静态变量）

/**
 * 单例模式-饿汉式（静态变量）
 *
 * 优点：类装载的时候完成实例化，避免了线程同步问题
 *
 * 缺点：可能造成内存的浪费
 */
class Singleton{
    // 1、将构造器私有化，外部就不能new了
    private Singleton(){
    }
    // 2、本类内部创建对象实例
    private final static Singleton instance = new Singleton();

    // 3、提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

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

/**
 * 单例模式-饿汉式（静态代码块）
 *
 *这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，
 * 也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
 * 结论： 这种单例模式可用，但是可能造成内存浪费
 */
class Singleton2{
    // 1、将构造器私有化，外部就不能new了
    private Singleton2(){
    }
    // 2、本类内部创建对象实例
    private /*final*/ static Singleton2 instance /*= new Singleton2()*/;

    // 静态代码块，完成对象的实例
    static {
        instance = new Singleton2();
    }

    // 3、提供一个公有的静态方法，返回实例对象
    public static Singleton2 getInstance(){
        return instance;
    }
}

（3）懒汉式(线程不安全，不推荐)

/**
 * 单例模式-懒汉式(线程不安全)
 *优缺点说明：
 *     1) 起到了Lazy Loading的效果，但是只能在单线程下使用。
 *     2) 如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及
 *     往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
 *
 *     3) 结论：在实际开发中，不要使用这种方式.
 */
class Singleton3{
    // 1、将构造器私有化，外部就不能new了
    private Singleton3(){
    }
    // 2、本类内部创建对象实例
    private  static Singleton3 instance ;

    // 3、提供一个静态的共有方法，当使用该方法的时候，才创建对象
    // 懒汉式
    public static Singleton3 getInstance(){
        if(instance == null){
            instance = new Singleton3();
        }
        return instance;
    }
}

（4）懒汉式(线程安全，不推荐)

/**
 * 单例模式-懒汉式(线程安全)
 优缺点说明：
        1) 解决了线程不安全问题
        2) 效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行
        同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，
        直接return就行了。方法进行同步效率太低

        3) 结论： 在实际开发中， 不推荐使用这种方式
 */
class Singleton4{
    // 1、将构造器私有化，外部就不能new了
    private Singleton4(){
    }
    // 2、本类内部创建对象实例
    private  static Singleton4 instance ;

    // 3、提供一个静态的共有方法，加入了同步处理的代码，当使用该方法的时候，才创建对象
    // 懒汉式
    public static synchronized Singleton4 getInstance(){
        if(instance == null){
            instance = new Singleton4();
        }
        return instance;
    }
}

（5）Double-Check（推荐）

/**
 * Double-Check
 *
 *优缺点说明：
 *      1) Double-Check概念是多线程开发中常使用到的， 如代码中所示，我们进行了两
 *      次if (singleton == null)检查，这样就可以保证线程安全了。
 *      2) 这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，
 *      直接return实例化对象，也避免的反复进行方法同步.
 *      3) 线程安全；延迟加载；效率较高
 *
 *      4) 结论：在实际开发中，推荐使用这种单例设计模式
 */
class Singleton5{
    // 1、将构造器私有化，外部就不能new了
    private Singleton5(){
    }
    // 2、本类内部创建对象实例
    private  static volatile Singleton5 instance ;

    // 3、提供一个静态的共有方法，加入了双重检查代码，解决线程安全问题，同时解决懒加载问题
    // 同时保证了效率，推荐使用
    public static  Singleton5 getInstance(){
        if(instance == null){
            synchronized (Singleton5.class){
                if(instance == null){
                    instance = new Singleton5();
                }
            }
        }
        return instance;
    }
}

（6）静态内部类（推荐）

/**
 * 静态内部类
 *
 *优缺点说明：
 *     1) 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
 *     2) 静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化
 *     时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
 *
 *     3) 类的静态属性只会在第一次加载类的时候初始化，所以在这里， JVM帮助我们
 *     保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
 *     4) 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
 *
 * 5) 结论：推荐使用
 */
class Singleton6{
    // 1、将构造器私有化，外部就不能new了
    private Singleton6(){
    }
    // 静态内部类
    private static class Singleton6Instance{
        private static final Singleton6 instance = new Singleton6();
    }

    public static  Singleton6 getInstance(){
        return Singleton6Instance.instance;
    }
}

（7）枚举实现单例（推荐）

public class _08_Singleton {
    public static void main(String[] args) {
        Singleton08 instance = Singleton08.INSTANCE;
    }


}

/**
 * 枚举实现单例
 *
 * 优缺点说明：
 *    1) 这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而
 *    且还能防止反序列化重新创建新的对象。
 *    2) 这种方式是Effective Java作者Josh Bloch 提倡的方式
 *
 *    3) 结论：推荐使用
 */
enum Singleton08{
    INSTANCE; //属性
}