引言
大浪淘沙,洗尽铅华无数，Java语言绵延数十载，前人留下了许多的轮子，Android使用java语言，自然需要用到这些轮子。今天，本少年就从头撸一把设计模式界的hello world——单例模式。
介绍
- 定义：在Android中，单例模式其实使用频率还是很高的，顾名思义，所谓单例就是指单个实例，如果一个类使用了单例模式，那么这个类的实例在整个APP中就只有一个实例。
- 应用场景：比如有一个util帮助类，它提供了一些功能，但是比较耗费资源，像线程池、IO访存、数据库操作等等。这种就不必new 很多实例，浪费资源。
几种写法
PS：XML布局
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context="st.zlei.com.androidsingleton.MainActivity"
android:orientation="vertical">
<Button
android:id="@+id/hungry_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="饿汉模式"
/>
<Button
android:id="@+id/lazy_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="基本懒汉模式" />
<Button
android:id="@+id/DCL_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="DCL单例模式" />
<Button
android:id="@+id/InnerClass_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="静态内部类单例模式" />
<Button
android:id="@+id/map_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="容器单例模式" />
</LinearLayout>
1. 饿汉模式
上代码：
单例类
Singleton_hungryMan 是单例的类。
public class Singleton_hungryMan {
private static final String TAG = "TestSingle";
private static Singleton_hungryMan singletonHungryMan = new Singleton_hungryMan();
//构造方法为private，其他地方就无法new本类的对象
private Singleton_hungryMan() {
}
//static以便类名.方法名调用
public static Singleton_hungryMan getInstance(){
return singletonHungryMan;
}
public void work(){
Log.d(TAG, "onClick: "+"我是饿汉模式里面的work方法");
}
}
调用Singleton_hungryMan
//1.test饿汉模式
hungry_button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//实例1：
Singleton_hungryMan singletonHungryMan1 = Singleton_hungryMan.getInstance();
Log.d(TAG, "onClick: "+singletonHungryMan1.hashCode());
singletonHungryMan1.work();
//实例2：
Singleton_hungryMan singletonHungryMan2 = Singleton_hungryMan.getInstance();
Log.d(TAG, "onClick: "+singletonHungryMan2.hashCode());
singletonHungryMan2.work();
}
});
结果
描述：
Singleton_hungryMan的构造方法是private所以不能new，只能通过getInstance()获取，而这个instance在声明的时候就已经初始化了，因此，Singleton_hungryMan这个类的实例只有一个。从log的打印也可以看出来两次得到的实例singletonHungryMan1 和singletonHungryMan12的哈希值是一样的，说明这两个对象指向的是同一个实例。
2. 基本的懒汉模式
上代码：
单例类
Singleton_lazyMan 是单例的类。
public class Singleton_lazyMan {
private static final String TAG = "TestSingle";
//私有的构造方法
private Singleton_lazyMan() {
}
private static Singleton_lazyMan singletonLazyMan = null;
//synchronized保证多线程的同步问题
public static synchronized Singleton_lazyMan getInstance(){
if (singletonLazyMan == null){
singletonLazyMan = new Singleton_lazyMan();
}
return singletonLazyMan;
}
public void work(){
Log.d(TAG, "onClick: "+"我是基本的懒汉模式里面的work");
}
}
*调用Singleton_lazyMan *
//2.test基本的懒汉模式
lazy_button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//实例1：
Singleton_lazyMan singletonLazyMan1 = Singleton_lazyMan.getInstance();
singletonLazyMan1.work();
Log.d(TAG, "onClick: "+singletonLazyMan1.hashCode());
//实例2：
Singleton_lazyMan singletonLazyMan2 = Singleton_lazyMan.getInstance();
singletonLazyMan2.work();
Log.d(TAG, "onClick: "+singletonLazyMan2.hashCode());
}
});
结果
描述：
同上面一样，两个实例的哈希值是一样的，说明单例的效果是达到了的。
synchronized的作用是保证多线程情况下单例对象的唯一性，试想当一个线程运行到这个地方的时候停下来了，另一个线程拿到了cpu去运行，是不是就会new 了两个Singleton_lazyMan()
这里写图片描述
还有一个问题，这种懒汉模式在每次调用时都会用synchronized同步，这样子会造成不必要的同步开销。基于此，接下来将介绍一种改良版的懒汉模式。
3. 改良版的懒汉模式（DCL）
上代码：
单例类
Sington_DCL 是单例的类。
public class Sington_DCL {
private static final String TAG = "TestSingle";
private Sington_DCL() {
}
private static Sington_DCL singtonDcl = null;
public static Sington_DCL getInstance(){
if (singtonDcl == null){
synchronized (Sington_DCL.class){
if (singtonDcl == null){
singtonDcl = new Sington_DCL();
}
}
}
return singtonDcl;
}
public void work(){
Log.d(TAG, "onClick: "+"我是DCL模式里面的work");
}
}
*调用Sington_DCL *
//3.test DCL单例模式
DCL_button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//实例1：
Sington_DCL singtonDcl1 = Sington_DCL.getInstance();
singtonDcl1.work();
Log.d(TAG, "onClick: "+singtonDcl1.hashCode());
//实例2：
Sington_DCL singtonDcl2 = Sington_DCL.getInstance();
singtonDcl2.work();
Log.d(TAG, "onClick: "+singtonDcl2.hashCode());
}
});
结果
描述：
从结果的图片看到，单例的效果是达到了的。
跟上面的懒汉模式相比，只有在第一次调用getInntance()才会同步，之后调用，便不会走synchronized里面的内容了，跟上面的本质区别还是同步锁加的位置不同导致的。
这里需要注意有两个null的判断，第一个if判断还是很好理解的，就是说，如果singtonDcl不是null就不必再执行new的操作了。第二个if判断比较复杂，简单的理解就是说：
singtonDcl = new Sington_DCL();
这句话在java中虽然就是一句，但是在底层CPU执行的时候是拆分成好几步的：
1.给实例分配内存 2.调用构造函数，初始化成员字段 3.将对象singtonDcl 指向刚刚分配的内存空间
问题在于这三步走，第一步是最先执行，但是第二步和第三步是乱序的，也就是说不确定2和3谁先谁后
那么问题来了，举个栗子，线程A执行了new Sington_DCL();`，底层cpu执行到1，3，即将执行2的时候线程B拿到了cpu，因为A已经把3执行了，这时候singtonDcl已经有内存空间了，换句话说singtonDcl已经不是null了，那么B就直接拿走了singtonDcl ，但事实上2还没有没有执行，B拿走的singtonDcl并不能用。所以还有一层if判断。
但是想想，这种情况发生的概率非常低的呀。
4. 静态内部类单例模式
上代码：
单例类：
public class Singleton_InnerClass {
private static final String TAG = "TestSingle";
private Singleton_InnerClass() {
}
public static Singleton_InnerClass getInstance(){
return SingletonHolder.mInstance;
}
private static class SingletonHolder {
//第一次调用mInstance会初始化
private static final Singleton_InnerClass mInstance = new Singleton_InnerClass();
}
public void work(){
Log.d(TAG, "onClick: "+"我是静态内部类单例模式里面的work");
}
}
调用方式都一样就不佳赘述了
5. 使用容器实现单例模式
上代码：
单例类：
public class SIngleton_MapManager {
private static final String TAG = "TestSingle";
private static Map<String,Object> map = new HashMap<String,Object>();
private SIngleton_MapManager() {
}
public static void registService(String key,Object obj){
if (!map.containsKey(key)){
map.put(key,obj);
}
}
public static Object getService(String key){
if (map.containsKey(key)){
Object obj = map.get(key);
return obj;
}
else {
return null;
}
}
}
调用方式
//5.test map容器单例模式
map_button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
SIngleton_MapManager.registService("a","A");
SIngleton_MapManager.registService("b","B");
//实例1：
Object service1 = SIngleton_MapManager.getService("a");
Log.d(TAG, "onClick: "+service1+"-----"+service1.hashCode());
//实例2：
Object service2 = SIngleton_MapManager.getService("a");
Log.d(TAG, "onClick: "+service2+"-----"+service2.hashCode());
}
});
描述：
这种方式很熟悉有没有？？没错，在Android中拿到系统的一些manager比如getSystemService（。。。）就是这种方式，这样子系统核心服务都以单例存在，减少了资源消耗。平时自己写单例模式好像不怎么用得到？
6. 总结
单例模式减少内存，减轻性能开销，使用非常广泛，本文介绍的几种单例的写法，推荐使用改良版的懒汉模式和静态内部类的单例模式这两种，当然单例还有其他写法，但是比较小众，这里就不再介绍了。
本文所使用的代码可以在本人的github上找到，点这里传送门走起
