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

引言

大浪淘沙,洗尽铅华无数，Java语言绵延数十载，前人留下了许多的轮子，Android使用java语言，自然需要用到这些轮子。今天，本少年就从头撸一把设计模式界的hello world——单例模式。

介绍

  1. 定义：在Android中，单例模式其实使用频率还是很高的，顾名思义，所谓单例就是指单个实例，如果一个类使用了单例模式，那么这个类的实例在整个APP中就只有一个实例。
  2. 应用场景：比如有一个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上找到，点这里传送门走起

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

友情链接更多精彩内容