剑指offer 面试题2—实现单例模式

终于把简直offer看完了一遍

所以第二遍我决定要美一个题自己去实现一遍，会加入自己的理解（但是不一定对哈）

题目：设计一个类，我们只能生成该类的一个实例。

饿汉试

package T2Singleton;

/**
 * 饿汉式
 * @author yxx
 *
 */
public class Singleton {

    //私有构造方法
    private Singleton() {}

    private static Singleton singleton = new Singleton();

    public static Singleton getInstance() {
        return singleton;
    }

}

我第一下想到的就是饿汉试的单例模式，因为他可以在多线程下使用，不想一般的懒汉式那样。

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的。

如果是懒汉式，我们就得加同步锁了

懒汉式

考虑同步，但是是对方法加锁

package T2Singleton;

/**
 * 多线程
 * 
 * @author yxx
 * 
 */
public class Singleton2 {

    //私有构造方法
    private Singleton2() {}

    private static Singleton2 instance = null;

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

考虑同步，对对象上锁，使锁的粒度变小

package T2Singleton;

/**
 * 多线程
 * 
 * @author yxx
 * 
 */
public class Singleton2 {

    // 私有构造方法
    private Singleton2() {}
    private static Singleton2 instance = null;

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

上面这种，加同步锁前后两次判断实例是否存在
加锁耗时。可以实现只有当single为null即没有创建时，需要加锁操作，当single创建出来之后，则无须加锁。

还有一种登记式的，有兴趣可以自行研究一下

package T2Singleton;

/**
 * 按需创建
 * 
 * @author yxx
 * 
 */
public class Singleton3 {

    Singleton3() {}

    public static Singleton3 getInstance() {
        return Nested.instance;
    }

    static class Nested {

        Nested() {}

        final static Singleton3 instance = new Singleton3();

    }
}

如果当我们第一次试图通过属性Single3.instance得到Single3的实例时，会自动调用Nested的静态构造函数创建实例instance。如果我们不调用属性，那么就不会触发运行，也不会创建实例。

饿汉式和懒汉式区别

这两种乍看上去非常相似，其实是有区别的，主要两点

1、线程安全：

饿汉式是线程安全的，可以直接用于多线程而不会出现问题，懒汉式就不行，它是线程不安全的，如果用于多线程可能会被实例化多次，失去单例的作用。
如果要把懒汉式用于多线程，有两种方式保证安全性，一种是在getInstance方法上加同步，另一种是在使用该单例方法前后加双锁。

2、资源加载：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，会占据一定的内存，相应的在调用时速度也会更快，
而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次掉用时要初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

所有源码均可去【GitHub】下载