Java设计模式——单例模式

特点：
单例类只能有一个实例
单例类必须自己创建自己的唯一实例
单例类必须给所有其他对象提供这一实例

实现单例模式：
饿汉式：在类加载时完成初始化(立即加载)，所以线程安全
懒汉式：在类加载时不会初始化(延时加载)，在多线程的情况下会产生多个single对象
静态内部类实现

1，饿汉式的两种方式

/**
 * 饿汉式1
 */

public class Singleton {

    private Singleton(){

    }

    private static Singleton singleton = new Singleton();

    public static Singleton getSingleton(){
        return singleton;
    }

}



/**
 * 饿汉式2
 */

public class Singleton1 {

    private Singleton1(){

    }

    private static Singleton1 singleton = null;

    //静态代码块
    static{
        singleton = new Singleton1();
    }

    public static Singleton1 getSingleton(){
        return singleton;
    }

}

2，懒汉式处理多线程情况下的安全机制

/**
 * 懒汉式1
 * 此种情况在多线程时就不是线程安全了
 */

public class Singleton2 {

    private Singleton2(){

    }

    private static Singleton2 singleton = null;

    public static Singleton2 getSingleton(){
        if (singleton == null){
            singleton = new Singleton2();
        }
        return singleton;
    }

}



/**
 * 懒汉式2
 * 使用synchronized加锁，实现线程安全
 */

public class Singleton3 {

    private Singleton3(){

    }

    private static Singleton3 singleton = null;

    public static Singleton3 getSingleton(){
        //双重检索
        if (singleton == null){
            synchronized (Singleton3.class){
                if (singleton == null){
                    singleton = new Singleton3();
                }
            }
        }
        return singleton;
    }

}

3，静态内部类

/**
 * 静态内部类
 */

public class Singleton4 {

    private Singleton4(){

    }

    private static class InSideClass{
        private static Singleton4 singleton = new Singleton4();
    }

    public static Singleton4 getSingleton(){
        return InSideClass.singleton;
    }

}