设计模式之单例模式

0. 单例模式准备

    0.1 单例模式的作用

       0.1.1 一个类只有一个实例

       0.1.2 该实例能够通过一个全局的方法获取到

    0.2 单例模式适用场景：

      0.2.1 多线程之间操作一个对象【共享一个资源】

      0.2.2 性能优化，减少创建对象的消耗【创建时间、对象所占的空间】

   0.3 单例模式的特点

       0.3.1 具有私有的构造器、一个静态变量、一个静态方法、[一个静态内部类]

 

1 饿汉模式

      1.1本质: 在类加载的时候就创建实例，需要获取实例时直接返回已创建的实例

      1.2 优点：线程安全

      1.3 缺点： 类加载的时候就创建实例，浪费空间

      1.4 代码示例：

package com.blueStarWei.pattern;

public class HungrySingleton {

    //create instance when loading class
    private static HungrySingleton singleton = new HungrySingleton();

    //将构造器私有化，防止外界通过该构造器创造多个实例
    private HungrySingleton(){}


    public static HungrySingleton getInstance(){
        return singleton;
    }
}

 

【为了减省空间的浪费，因此人们想到了在需要获取实例的时候创建实例，因此产生了懒汉模式】

 

2. 懒汉模式

  2.1 本质： 当需要获取实例的时候，先进行判断，如果实例不存在，就创建实例，否则直接返回已存在的实例【避免了在加载类的同时直接创建实例】

  2.2 懒汉模式1.0版本

package com.blueStarWei.pattern;

public class LazySingleton {

    private static LazySingleton singleton;

    private LazySingleton(){}
    
    public static LazySingleton getInstance(){
        if(singleton == null){
            singleton = new LazySingleton();
        }
        return singleton;
    }
}

    2.2.1 优点：节省了空间

    2.2.2 缺点： 线程不安全【如果多个线程同时执行if判断，因为多个线程获取的singleton1都是空，所以会创建多个实例】

 

【为了避免懒汉模式的线程不安全问题，人们想到了对getInstance（）添加synchronized修饰符，于是产生了懒汉模式1.1版本】

 

  2.3 懒汉模式1.1版本

package com.blueStarWei.pattern;

public class LazySingleton1 {

    private static LazySingleton1 singleton;

    private LazySingleton1(){}
    
    public static synchronized LazySingleton1 getInstance(){
        if(singleton == null){
            singleton = new LazySingleton1();
        }
        return singleton;
    }
}

    2.3.1 优点： 节省空间、线程安全

    2.3.2 缺点： 性能不好【synchronized会造成线程阻塞】

 

【为了避免线程阻塞的出现，人们又想到了双重校验锁，因此产生了懒汉模式1.2版本】

 

  2.4 懒汉模式1.2版本【双重检查枷锁方式/double-check】

package com.blueStarWei.pattern;

public class LazySingleton2 {

    //使用volatile阻止命令重排,保证多线程正确处理singleton变量
    private volatile static LazySingleton2 singleton;

    private LazySingleton2(){}
    
    public static LazySingleton2 getInstance(){
        if(singleton == null){
            //该部分只会被执行一次
            synchronized (LazySingleton1.class) {
                if(singleton == null){
                    singleton = new LazySingleton2();                                    
                }
            }
        }
        return singleton;
    }
}

    2.4.1 优点： 节省空间，线程安全，性能相对有优化【只是优化了已经存在实例的情况，即：当实例已经被创建，再调用getInstance()的时候就不会经过synchronized修饰符】

    2.4.2 缺点：使用了synchronized修饰符，线程仍然会有阻塞情况的发生。

 

【为了避免使用synchronized修饰符，人们想到了静态内部类（因为一个类被加载，当且仅当该类的某个静态成员被调用），于是懒汉模式2.0时代到来】

 

  2.5 懒汉模式2.0版本【推荐版本】

package com.blueStarWei.pattern;
/**
 * 因为对象实例化是在内部类加载时构建，因此是线程安全的【毕竟类只加载一次嘛】
 * @author HuWei
 *
 */
public class LazySingleton3 {

    private LazySingleton3(){}
    
    //当getInstance()方法第一次被调用时，内部类被加载
    static class SingletonHolder {
        private static final LazySingleton3 singleton3 = new LazySingleton3();
    }
    
    //没有使用synchronized修饰符，避免了性能损耗
    public static LazySingleton3 getInstance() {
        return SingletonHolder.singleton3;
    }
}

     2.5.1 优点： 节省空间、线程安全、避免性能的额外损耗

     2.5.2 缺点： 在反射作用下，单例模式会被破坏

 

【为了防止反射破坏单例模式，所以产生了单例模式3.0版本】

 

  2.6 单例模式3.0版本

     2.6.1 版本代码

package com.blueStarWei.pattern;

public class LazySingleton4 {
    
    /* -------添加部分 start-------- 
     * 作用：第二次调用构造函数（即：创建第二个实例）时抛出异常
     * */
    private static boolean initialized = false;
    
    private LazySingleton4() {
        synchronized (LazySingleton4.class) {
            if(initialized == false){
                initialized = !initialized;
            }else{
                throw new RuntimeException("Singleton has been broken!");
            }
        }
    }
    /* -------添加部分 end-------- */
    
    //当getInstance()方法第一次被调用时，内部类被加载
        static class SingletonHolder {
            private static final LazySingleton4 singleton4 = new LazySingleton4();
        }
        
        //没有使用synchronized修饰符，避免了性能损耗
        public static LazySingleton4 getInstance() {
            return SingletonHolder.singleton4;
        }
}

        2.6.1.1  版本Demo

package com.blueStarWei.pattern;

import java.lang.reflect.Constructor;
/**
 * 通过反射调用时会报错
 * Caused by: java.lang.RuntimeException: Singleton has been broken!
 * @author HuWei
 *
 */
public class LazySingleton4Demo {

    public static void main(String[] args) {
        //通过getInstance()创建实例
        LazySingleton4 sington = LazySingleton4.getInstance();
        
        //通过反射创建实例
        LazySingleton4 sington4 = null;
        try {
            Class clazz = LazySingleton4.class;
            Constructor constructor = clazz.getDeclaredConstructor();
            constructor.setAccessible(true);
            sington4 = constructor.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        } 
        
        System.out.println("getInstance() : "+sington);
        System.out.println("invoke : "+sington4);
    }
}

         2.6.1.2 Demo日志

java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source)
    at java.lang.reflect.Constructor.newInstance(Unknown Source)
    at com.blueStarWei.pattern.LazySingleton4Demo.main(LazySingleton4Demo.java:21)
Caused by: java.lang.RuntimeException: Singleton has been broken!
    at com.blueStarWei.pattern.LazySingleton4.(LazySingleton4.java:19)
    ... 5 more
getInstance() : com.blueStarWei.pattern.LazySingleton4@7852e922
getInstance() : com.blueStarWei.pattern.LazySingleton4@7852e922
invoke : null

 

    2.6.2 反射破环单例模式示例

package com.blueStarWei.pattern;

import java.lang.reflect.Constructor;
/**
 * 不难发现，通过getInstance()和反射创建的实例的内存地址不一样，即不是同一个实例对象
 * @author HuWei
 *
 */
public class LazySingleton3Demo {

    public static void main(String[] args) {
        //通过getInstance()创建实例
        LazySingleton3 sington = LazySingleton3.getInstance();
        LazySingleton3 sington2 = LazySingleton3.getInstance();
        
        //通过反射创建实例
        LazySingleton3 sington3 = null;
        try {
            Class clazz = LazySingleton3.class;
            Constructor constructor = clazz.getDeclaredConstructor();
            constructor.setAccessible(true);
            sington3 = constructor.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        } 
        
        System.out.println("getInstance() : "+sington);
        //getInstance() : com.blueStarWei.pattern.LazySingleton3@15db9742
        
        System.out.println("getInstance() : "+sington2);
        //getInstance() : com.blueStarWei.pattern.LazySingleton3@15db9742
        
        System.out.println("invoke : "+sington3);
        //invoke : com.blueStarWei.pattern.LazySingleton3@6d06d69c
    }
}

 

 【在分布式系统中，单例类有时需要实现Serializable接口。以上版本通过序列和反序列化产生的实例将会不是同个实例对象，所以产生了懒汉模式4.0版本】

 

  2.7 懒汉模式4.0版本

    2.7.1 Demo代码

package com.blueStarWei.pattern;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class LazySingleton4Demo2 {

    public static void main(String[] args) {
        
        LazySingleton4 singleton = LazySingleton4.getInstance();
        try {
            ObjectOutput out = new ObjectOutputStream(new FileOutputStream("fileName.txt"));
            out.writeObject(singleton);
            out.close();
            //deserializable from file to object
            ObjectInput in = new ObjectInputStream(new FileInputStream("fileName.txt"));
            LazySingleton4 singleton2 = (LazySingleton4)in.readObject();
            in.close();
            
            System.out.println("Serializable : "+singleton);
                        
            System.out.println("Deserializable : "+singleton2);
            
        } catch (Exception e) {
            e.printStackTrace();
        } 
        
    }
}

 

  2.7.2 反序列返回不同的对象示例

public class LazySingleton4 implements Serializable

        2.7.2.1 Demo日志

Serializable : com.blueStarWei.pattern.LazySingleton4@33909752
Deserializable : com.blueStarWei.pattern.LazySingleton4@776ec8df

 

  2.7.3 版本代码

package com.blueStarWei.pattern;

import java.io.Serializable;

public class LazySingleton4 implements Serializable{
    
    private static final long serialVersionUID = 1L;
    
    private static boolean initialized = false;

    private LazySingleton4() {
        synchronized (LazySingleton4.class) {
            if(initialized == false){
                initialized = !initialized;
            }else{
                throw new RuntimeException("Singleton has been broken!");
            }
        }
    }
    
    static class SingletonHolder {
        private static final LazySingleton4 singleton4 = new LazySingleton4();
    }
        
    public static LazySingleton4 getInstance() {
        return SingletonHolder.singleton4;
    }
    
    /* ----添加部分 start---- */
    /**
     * 反序列化的结果仍然通过getInstance()获取
     */
    private Object readResolve(){
        return getInstance();
    }
    /* ----添加部分 end---- */
}

        2.7.3.1 Demo日志

Serializable : com.blueStarWei.pattern.LazySingleton4@33909752
Deserializable : com.blueStarWei.pattern.LazySingleton4@33909752

 

3 其它问题

  3.1 如果存在多个类加载器，可能会产生多个单例并存的现象。

       3.1.1 原因： 每个类加载器都定义了一个命名空间，如果存在多个类加载器，不同的类加载器可能会加载同一个类，所以同一类会被加载多次。

       3.1.2 解决方法： 自行指定类加载器，并指定同一个类加载加载器。

  3.2 单例类不能被继承

      3.2.1 原因： 继承单例类必须将单例类构造器的访问修饰符改成public/protected，这样会导致其他类也可以实例化该单例类，破坏了单例模式

      3.2.2 解决方法： 不继承单例类

  3.3 为何全局变量会比单例模式差？

     3.3.1 全局变量基本上就是对对象的静态引用，全局变量虽然能提供全局访问，但是不能保证只有一个实例。

 

4 总结

   实际项目中，一般从懒汉模式2.0、3.0、4.0版本中选择一种即可

 

         更多内容，请访问：http://www.cnblogs.com/BlueStarWei/