单例模式

 * 恶汉模式
 * 缺点:
 * getInstance()没有同步，可能会出现线程安全问题。
 */
public class MyObject {

    private static MyObject sObject = new MyObject();

    private MyObject(){}

    public static MyObject getInstance(){
        return sObject;
    }

}

 * 懒汉模式：
 * 在多线程情况下，会出现取出多个实例的情况
 */
public class MyObject1 {

    private static MyObject1 sMyObject1;
    private MyObject1(){}
    //同步方法能解决创建多个实例的问题，但是效率低
    public synchronized static MyObject1 getInstance(){
        return sMyObject1 == null ? new MyObject1() : sMyObject1;
    }

}

 * 懒汉模式：
 * 在多线程情况下，会出现取出多个实例的情况
 */
public class MyObject2 {

    //使用双锁机制即保证了同步代码块的异步执行性
    //又保证了单列的效果
    private volatile static MyObject2 sMyObject1;
    private MyObject2(){}
    //同步代码块能在一定程度上提升效率，但是效率不会有显著变化
    //如果只是同步实例化代码，并不能解决多线程同步的问题
    public static MyObject2 getInstance(){
        synchronized (MyObject2.class){
            return sMyObject1 == null ? new MyObject2() : sMyObject1;
        }
    }

}

 * 静态内置类可以达到线程安全的问题，如果遇到序列化对象时，使用默认的方式运行得到的结果还是多列的
 */
public class MyObject3  implements Serializable{

    private static final long serialVersionUID = 888L;

    private static class MyObjectHolder{
        private static MyObject3 sMyObject3 = new MyObject3();
    }

    private MyObject3() {
    }

    public static MyObject3 getInstance(){
        return MyObjectHolder.sMyObject3;
    }

}

 * 静态代码块中的代码在使用类的时候已经执行
 */
public class MyObject4 {

    private static MyObject4 instance = null;
    private MyObject4(){}
    static{
        instance = new MyObject4();
    }
    public static MyObject4 getInstance(){
        return instance;
    }

}

枚举也可以实现单例，实际工作中我还能少见到有用单例模式使用枚举的。这里我就不列出来了