设计模式之一----单例模式

在一个系统里，对于某些对象，有且只能有一个，当我们有这样的需求的时候，就需要用到单例模式了。

单例模式分为懒汉模式和饿汉模式。我们使用代码来进行说明:

首先创建一个用到了饿汉模式的Singleton类在com.single下:

package com.single;/* * 单例模式 * 场合：保证有些对象有且只有一个 * 类型：饿汉模式 * */public class Singleton {    //1、将构造方法私有化 不允许外部直接创建对象    private Singleton(){}        //2、类的唯一实例 只要类创建 该实例就会被创建    private static Singleton instance = new Singleton();        //3、提供一个用于获取实例的方法    public static Singleton getInstance(){        return instance;//类一被创建 该实例就会被创建    }}

然后创建一个用到了懒汉模式的Singleton2在com.single下：

package com.single;public class Singleton2 {    //1、将构造方法私有化    private Singleton2(){}    //2、声明类的唯一实例    private static Singleton2 instance;//类加载的时候没有生成这个实例 而是用户获取来才生成这个实例    //3、提供一个用于获取实例的方法    public static Singleton2 getInstance(){        if(instance == null){//仅当第一次尝试获取实例的时候才生成实例            instance = new Singleton2();        }        return instance;    }}

最后写一个测试类Test在com.single下:

package com.single;public class Test {    public static void main(String[] args) {        //饿汉模式        Singleton s1 = Singleton.getInstance();//获取实例        Singleton s2 = Singleton.getInstance();//获取实例        System.out.println(s1==s1);//true 同一个实例 无论获取多少次都是同一个对象                //懒汉模式        Singleton2 s3 = Singleton2.getInstance();        Singleton2 s4 = Singleton2.getInstance();        System.out.println(s3==s4);//true 也是同一个实例                //懒汉模式与饿汉模式的区别：        //饿汉模式加载类的速度比较慢，但是允许时获取对象速度比较快 线程安全         //懒汉模式加载类比较快 但是运行时获取对象的速度比较慢 线程不安全    }}

前面我们提到了懒汉模式是线程不安全的，所以我们能不能想办法做成线程安全的呢？ 来尝试一下：

package com.single;public class Singleton2 {    private static Object lock = new Object();//生成一把锁    //1、将构造方法私有化    private Singleton2(){}    //2、声明类的唯一实例    private static Singleton2 instance;//类加载的时候没有生成这个实例 而是用户获取来才生成这个实例    //3、提供一个用于获取实例的方法    public static Singleton2 getInstance(){    synchronized(lock){//加上锁        if(instance == null){//仅当第一次尝试获取实例的时候才生成实例            instance = new Singleton2();        }    }        return instance;    }}

这样做是不是仿佛没什么问题了，但是我们要知道实际上加锁是开销特别大的，除了第一次生命单例以外我们用不到每次都加锁，所以我们采用双重校验锁：

package com.singleton;public class Singleton2 {    private Singleton2(){};    private static Singleton2 instance;    private static Object lock = new Object();    public static Singleton2 getInstance(){        if(instance == null){//只有第一次创建实例才加锁            synchronized(lock){//加锁实际上很浪费时间                if(instance == null){                    instance = new Singleton2();                    System.out.println("创建成功");                }            }        }        return instance;    }    public void save(){        System.out.println("保存成功");    }}

仿佛没什么问题了是吧，但是由于JVM指令重排优化特性的存在，导致初始化Singleton和将对象地址赋给instance字段的顺序可能是不确定的，在某个线程创建单例对象时，在构造方法被调用之前，就为该对象分配了内存空间并将对象的字段设置为默认值。此时就可以将分配的内存地址赋值给instance字段了，然而该对象可能还没有初始化。若紧接着另外一个线程来调用getInstance，取到的就是状态不正确的对象，程序就会出错。然而volatile关键字除了保障变量被多线程访问的安全性的同时，还可以禁止JVM重排优化，所以这个地方最好在instance前加上volatile关键字：

package com.singleton;public class Singleton2 {    private Singleton2(){};    private static volatile Singleton2 instance;//懒汉模式 默认线程不安全 慢    private static Object lock = new Object();    public static Singleton2 getInstance(){        if(instance == null){            synchronized(lock){//加锁实际上很浪费时间                if(instance == null){                    instance = new Singleton2();                    System.out.println("创建成功");                }            }        }        return instance;    }    public void save(){        System.out.println("保存成功");    }}

然而现在在不需要继承这个单例对象对应的类的时候有一种最简单，也绝对线程安全的方式：单枚举，详情点击链接