首页 > > 程序设计 > Java技术 >

《剑指Offer》——Singleton（Java版）

2018-08-17 09:40:51来源：博客园阅读 ()

1.单例模式的定义

　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

2.单例模式的特点

　　单例类只能有一个实例。

　　单例类必须自己创建自己的唯一实例。

　　单例类必须给所有其他对象提供这一实例。

3.单例模式的Java代码

　　单例模式分为懒汉式（需要才去创建对象）和饿汉式（创建类的实例时就去创建对象）。

4.饿汉式

　　在静态代码块实例对象

//在静态代码块实例对象
public class Singleton {

    private static Singleton singleton;

    static {
        singleton = new Singleton();
    }

    public static Singleton getInstance() {
        return singleton;
    }

    private Singleton() {}
}

　　属性实例化对象

//饿汉模式：线程安全，耗费资源。
class SingletonHungry {

    private static final SingletonHungry singletontest = new SingletonHungry();

    public static SingletonHungry getSingletontest() {
        return singletontest;
    }

    private SingletonHungry() {}
}

以上，饿汉式只要调用该类，就会实例化一个对象，非常的占用资源。

5.懒汉式

　　非线程安全，只有加入线程锁（synchronized关键字）来保证线程安全。

//懒汉模式：需加入线程锁(synchronized 关键字)，保证安全
class SingletonSlacker1 {

    private static SingletonSlacker1 singleton;

    public synchronized static SingletonSlacker1 getInstance() {

        if (singleton == null) {
            singleton = new SingletonSlacker1();
        }
        return singleton;
    }
    private SingletonSlacker1() {}
}

当然，该方式，虽然保证了线程的安全，但是只能有一个线程调用，其他线程必须等待。

　　线程安全：双重检查锁（同步代码块）

//懒汉模式：加入双重锁
class SingletonSlacker2 {

    private static SingletonSlacker2 singleton;

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

    private SingletonSlacker2() { }
}

6.指令重排序

　　其实创建一个对象，往往包含三个过程。
　　对于singleton = new Singleton()，这不是一个原子操作，在 JVM 中包含的三个过程。

　　　　1、给 singleton 分配内存

　　　　2、调用 Singleton 的构造函数来初始化成员变量，形成实例

　　　　3、将singleton对象指向分配的内存空间（执行完这步 singleton才是非 null 了）

　　针对JVM中的指令重排序，我们可以使用 Volatile关键字来保证线程安全。

class SingletonVolatile{
    //volatile的作用是 ：保证可见性，禁止重排序，但不能保证原子性。
    private volatile static SingletonVolatile singleton;

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

    private SingletonVolatile(){}
}