单例的几种写作方式和序列化

2015-09-02 16:02:07

推荐一篇大神的文章，好久之前就看过这篇文章，而且本文的思路就来自这篇文章~其实有了大牛的文章，本文可写可不写，但是为了给自己总结一下，就写了~

http://callmegod.iteye.com/blog/1474441

单例的作用想必大家都知道，也一直在用，但是到底怎样的单例是“比较”完美的单例模式呢？我也不知道，但是我一直在寻找答案~

下面我简单总结一下单例吧，否则太乱了

Part 1：单例的几种实现方式

1. 恶汉式：指在类加载或者被初始化的时候，就创建一个单例对象，有好几个变种

第一种：类加载时创建对象

public class SingletonObj {
    public static final SingletonObj INSTANCE = new SingletonObj();

    private SingletonObj() {}
}

第二种：类加载时创建对象，但是对象是私有的，只能通过static的方法获取，好像更加“面向对象”

public class SingletonObj {
    private static final SingletonObj INSTANCE = new SingletonObj();

    private SingletonObj() {}

    public static SingletonObj getInstance() {
        return INSTANCE;
    }
}

第三种：类初始化的时候创建对象

public class SingletonObj {
    public static SingletonObj INSTANCE;

    static {
        INSTANCE = new SingletonObj();
    }

    private SingletonObj() {}

    private static SingletonObj getInstance() {
        return INSTANCE;
    }
}

2. 懒汉式：使用时才创建对象，相比于恶汉式，这种方式会延迟加载。

第一种：线程不安全

public class SingletonObj {
    public static SingletonObj INSTANCE;

    private SingletonObj() {}

    private static SingletonObj getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new SingletonObj();
        }
        return INSTANCE;
    }
}

第二种：线程安全，同时支持双重检查机制，这种也是最常见的单例模式(这种方式不推荐)

public class SingletonObj {
    private static final Object sLocker = new Object();
    public static SingletonObj INSTANCE;

    private SingletonObj() {
    }

    private static SingletonObj getInstance() {
        if (INSTANCE == null) {
            synchronized (sLocker) {
                if (INSTANCE == null) {
                    INSTANCE = new SingletonObj();
                }
            }
        }
        return INSTANCE;
    }
}

这种方式有自己的弊端：有种说法，说是jdk1.5后才能保证达到单例效果，但是据我所知，这种方式来自C语音的双重检查机制，在Java中不见得能完全适用。

所以保险的加锁方式如下：

public class SingletonObj {
    public static SingletonObj INSTANCE;

    private SingletonObj() {
    }

    private synchronized static SingletonObj getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new SingletonObj();
        }
        return INSTANCE;
    }
}

3. 静态内部类方式：加锁的方式能做到线程安全，但是加锁会导致效率比较低，而这种方式既能满足线程安全的要求，而且效率比较高

public class SingletonObj {
    private static class SingletonHolder {
        public static final SingletonObj INSTANCE = new SingletonObj();
    }

    private SingletonObj() {
    }

    private static SingletonObj getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

主要利用到静态类只会被JVM加载一次的特性~所以即便是多线程，也不会产生两个对象。这也是一种比较优雅的方式。

4. 《Effective Java》中提到一种更好的方法：单元素的枚举类型，大体实现如下(极棒的方式)

public enum SingletonEnum {
    INTANCE(12, "Niu");

    private int age;
    private String name;
    SingletonEnum(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public void doSomething() {
        System.out.println("SingletonEnum doSomething");
    }
}

好处：线程安全，序列化/反序列化安全

弊端：失去了类的一些特性，因此不够流行

Part 2：

1. 上面提到了序列化，我们都知道，所谓序列化/反序列化就是对象和流之间的一种转换方式。因为对象是不能直接保存在硬盘或者通过网络传输的，但是序列化成流之后，原则上你想干嘛都行。但是单例的序列化比较特殊，我们知道，单例的作用就是保证JVM中只有一个对象，那么如何保证反序列化后的对象和序列化之前的是同一个对象呢？

public class SingletonCase implements Serializable {
    private static class SingltonHolder {
        public static final SingletonCase INSTANCE = new SingletonCase();
    }

    private int age;
    private String name;
    public static SingletonCase getInstance() {
        return SingltonHolder.INSTANCE;
    }

    private SingletonCase() {
        age = 133;
        name = "David";
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    private Object readResolve() {
        return SingltonHolder.INSTANCE;
    }
}

需要添加如上绿色代码，这是一个方法，返回值必须是Object，而不能是自己定义的对象。这个方法的作用是：每次反序列化完成前都会去调用readResolve()方法，将用原对象取代新创建出来的对象，这样就保证了序列化前后对象的唯一性。

单例的线程安全和序列化一直是个比较难缠的安全问题，所以单元素的枚举类型实现单例，既能保证线程安全性，又能保证序列化安全，可谓是一种perfect的方案~~

2. 关于transient

 如果你不想某个成员变量被序列化，那么就可以用这个关键字来修饰~具体的使用大家问度娘。