设计模式: 单例模式

单例模式时指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点，在我们生活中有很多例子，比如一个公司只有一个CEO。
下面来看下单例模式的几种实现：

饿汉式单例：
饿汉式单例模式在类加载时就创建好对象，等着调用者来获取这个对象
优点：绝对的线程安全，因为没有加锁，执行效率高
缺点：不管这个对象有没有被用到都会占着内存，浪费资源

public class SingletonHungry {

    public static SingletonHungry SINGLETONHungry = new SingletonHungry();

    private SingletonHungry() {
    }

    public static SingletonHungry getInstance() {
        return SINGLETONHungry;
    }
}

懒汉式单例：
优点：实现了懒加载，适合在单线程下使用
缺点：多线程下会存在线程不安全的问题

public class Singleton1 {

    public static Singleton1 singleton1 = null;

    private Singleton1() {
    }

    public static Singleton1 getInstance() {
        if (singleton1 == null) {
            singleton1 = new Singleton1();
        }
        return singleton1;
    }
}

根据上面这个懒汉式单例我们可以做优化:

public class Singleton2 {

    public static Singleton2 singleton1 = null;

    private Singleton2() {
    }

    public static synchronized Singleton2 getInstance() {
        if (singleton1 == null) {
            singleton1 = new Singleton2();
        }
        return singleton1;
    }
}

上面Singleton2中给创建对象方法加入了同步锁，这样可以保证线程安全，但是效率低，我们还可以这样:

public class Singleton3 {

    public static Singleton3 singleton3 = null;

    private Singleton3() {
    }

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

在代码块中加入同步锁,这样会比在方法上加同步锁性能会高一些，同时也保证了对象实例只能创建一次，我们来模仿多线程情况测试一下：

public class Singleton3Test {

    public static void main(String[] args) throws Exception {

        Thread thread1 = new Thread(
                new Runnable() {
                    public void run() {
                        Singleton3 singleton3 = Singleton3.getInstance();
                        System.out.println("Singleton3的hashCode:" + singleton3.hashCode());
                    }
                });

        Thread thread2 = new Thread(
                new Runnable() {
                    public void run() {
                        Singleton3 singleton3 = Singleton3.getInstance();
                        System.out.println("Singleton3的hashCode:" + singleton3.hashCode());
                    }
                });

        thread1.start();
        thread2.start();
    }
}

测试方法运行结果：
Singleton3的hashCode:407939276
Singleton3的hashCode:1224672400
代码块中加同步锁结果还是没有保证线程的安全，下面我们对它再来改进一下：

public class Singleton4 {

    public static Singleton4 singleton4 = null;

    private Singleton4() {
    }

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

这次的运行结果:
Singleton4的hashCode:802393921
Singleton4的hashCode:802393921
可以看到这次保证了线程的安全,这种单例模式叫双重锁判断，其实还有一种方式可以实现懒汉式单例，那就是使用内部类加载机制，内部类只有在被调用的时候才会加载，利用JVM类加载时的线程安全特征来保证对象只加载一次

public class Singleton {

    private Singleton() {
    }

    public static class a {
        public static Singleton SINGLETON = new Singleton();
    }

    public static Singleton getInstance() {
        return a.SINGLETON;
    }
}

上面可以实现一个对象只能被创建一次，但是JAVA中还有很多方式可以创建新的对象，比如反射、反序列化、克隆下面我们需要防止这些操作再生成一个同样的对象

public class Singleton implements Serializable {

    private static final long serialVersionUID = -7386993593450962036L;

    public static Singleton singleton = null;

    private Singleton() {
        // 防止反射破坏单例
        if (singleton != null) {
            throw new RuntimeException("Singleton 只能被创建一次");
        }
    }

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

    /**
     * 防止反序列化破坏单例
     *
     * @return Singleton
     */
    private Object readResolve() {
        return singleton;
    }

    /**
     * 防止克隆破坏单例
     *
     * @return
     */
    @Override
    public Singleton clone() {
        return singleton;
    }
}

这样就是一个比较完美的单例模式了，保证了线程安全，实现了懒加载，防止反序列化、克隆、反射来破坏单例。