单例模式的常用写法

Author Avatar
Jerey_Jobs 7月 13, 2016

设计模式

定义

单例模式最初的定义出现于《设计模式》（艾迪生维斯理, 1994）：“保证一个类仅有一个实例，并提供一个访问它的全局访问点。”

而我对单例的理解是，在可控的范围内充当全局变量的作用，就相当于C语言中一个全局结构体。

一些资源管理器常常设计成单例模式。
在计算机系统中，需要管理的资源包括软件外部资源，譬如每台计算机可以有若干个打印机，但只能有一个Printer Spooler， 以避免两个打印作业同时输出到打印机中。每台计算机可以有若干传真卡，但是只应该有一个软件负责管理传真卡，以避免出现两份传真作业同时传到传真卡中的情况。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。

优点

  • 由于单例模式在内存中只有一个实例，减少了内存开销。
  • 单例模式可以避免对资源的多重占用，例如一个写文件时，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
  • 单例模式可以再系统设置全局的访问点，优化和共享资源访问。由于单例模式在内存中只有一个实例，减少了内存开销。

实现

网上盛行的单例模式的多种写法，而事实上，对于个人来说，我们只需要熟记自己喜欢的写法就好了，而那些非延迟加载的，非线程安全的，同步锁导致效率低的，没必要再说怎么写了。但是序列化与反序列化的问题，由于是否要考虑该问题，所以有以下解决方案

1. 内部类方式（我最爱的方式）

内部类SingletonHolder只有在getInstance()方法第一次调用的时候才会被加载，实现了延迟加载，而且其加载过程是线程安全的，但是序列化反序列化问题没有解决

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Singleton {
   private Singleton() { }
   private static class SingletonHolder {
      private final static Singleton INSTANCE = new Singleton();
   }
   public static Singleton getInstance() {
      return SingletonHolder.INSTANCE;
   }
   public void test(){
   }
}
使用
	Singleton.getInstance().test();

2.优雅的枚举方式

使用枚举除了线程安全和防止反射强行调用构造器之外，还提供了自动序列化机制，防止反序列化的时候创建新的对象。因此，Effective Java推荐尽可能地使用枚举来实现单列，但是在Android平台上却是不被推荐的
（PS：枚举的原理并非想当然的内部静态变量原理，枚举原理）

1
2
3
4
5
6
7
8
9
10
public enum Singleton {
    INSTANCE;
    private String name;
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
}

Android中的应用

如我们一开始说的，许多资源管理器设计成单例模式，那么我们的Android系统本身就有很多资源需要管理，最常见的是LayoutInflater 是单例模式，还有许多的manager，

  1. BluetoothOppManager
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class BluetoothOppManager {
    private static final String TAG = "BluetoothOppManager";
    private static final boolean V = Constants.VERBOSE;
    // 创建private static类实例
    private static BluetoothOppManager INSTANCE;
    /** Used when obtaining a reference to the singleton instance. */
    private static Object INSTANCE_LOCK = new Object();
    ...
    /**
     * Get singleton instance.
     */
    public static BluetoothOppManager getInstance(Context context) {
        synchronized (INSTANCE_LOCK) {
            if (INSTANCE == null) {
                INSTANCE = new BluetoothOppManager();
            }
            INSTANCE.init(context);
            return INSTANCE;
        }
    }
  1. InputMethodManager
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public final class InputMethodManager {
    static final boolean DEBUG = false;
    static final String TAG = "InputMethodManager";
    static final Object mInstanceSync = new Object();
    static InputMethodManager mInstance;
    final IInputMethodManager mService;
    final Looper mMainLooper;
    /**
     * Retrieve the global InputMethodManager instance, creating it if it
     * doesn't already exist.
     * @hide
     */
    static public InputMethodManager getInstance(Context context) {
        return getInstance(context.getMainLooper());
    }
    /**
     * Internally, the input method manager can't be context-dependent, so
     * we have this here for the places that need it.
     * @hide
     */
    static public InputMethodManager getInstance(Looper mainLooper) {
        synchronized (mInstanceSync) {
            if (mInstance != null) {
                return mInstance;
            }
            IBinder b = ServiceManager.getService(Context.INPUT_METHOD_SERVICE);
            IInputMethodManager service = IInputMethodManager.Stub.asInterface(b);
            mInstance = new InputMethodManager(service, mainLooper);
        }
        return mInstance;
    }
}

  1. 数不胜数…

    ###谢谢大家阅读，如有帮助，来个喜欢或者关注吧！

本文作者：Anderson/Jerey_Jobs

简书地址：Anderson大码渣

github地址：[Jerey_Jobs][3]

expand_less