设计模式——单例设计模式

什么是设计模式？

是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。一些开发的套路，用于解决某一些特定场景的思想。

什么是单例设计模式？

是一种最最常见的一种模式，保证整个程序中只有一个实例，这是最基本的，真正做到整个系统中唯一并不容易，通常还要考虑反射破坏、序列化/反序列化、对象垃圾回收等问题。

参考文章：https://blog.csdn.net/tjiyu/article/details/76572617

单例模式的几种实现方式

单例实现方式1.饿汉式

/**
 * 饿汉式-随着类的加载会自动new出对象
 */

public class Singleton {
    private Singleton() {
    }//私有化构造器

    private static Singleton mInstance = new Singleton();

    public static Singleton getInstance() {
        return mInstance;
    }

}

饿汉式，简单可用。这种方式比较常用，它基于JVM的类加载器机制避免了多线程的同步问题，对象在类装载时就实例化，所以称为饿汉式。
Lazy 初始化：否；
多线程安全：是；
优点：没有加锁，执行效率会提高。
缺点：没有Lazy初始化，可能有时候不需要使用，浪费内存。

单例实现方式2.懒汉式1

多线程并发的时候会有问题，有可能会存在多个实例mInstance

/**
 * 懒汉式1-多线程并发的时候会有问题，有可能会存在多个实例mInstance
 */

public class Singleton {
    private Singleton() {
    }//私有化构造器

    private static Singleton mInstance;

    public static Singleton getInstance() {
        if (mInstance == null)
            mInstance = new Singleton();
        return mInstance;
    }

}

Lazy 初始化：是；
多线程安全：否；
能够在getInstance()时再创建对象，所以称为懒汉式。这种实现最大的问题就是不支持多线程。因为没有加锁同步。

单例实现方式3.懒汉式2

解决多线程并发问题，加一个同步锁，但是又会出现效率问题，就是每次getInstanc的时候都会经过同步锁的判断！

/**
 * 懒汉式2-解决多线程并发问题，加一个同步锁，但是又会出现效率问题，就是每次getInstanc的时候都会经过同步锁的判断！
 */

public class Singleton {
    private Singleton() {
    }//私有化构造器

    private static Singleton mInstance;

    public static synchronized Singleton getInstance() {
        if (mInstance == null)
            mInstance = new Singleton();
        return mInstance;
    }

}

Lazy 初始化：是
多线程安全：是
除第一次使用，后面getInstance()不需要同步；每次同步，效率很低。

单例实现方式4.懒汉式3(DCL)

双重检查，只会执行一次同步锁。(这种方式其实还是有问题！引出volatile关键字)

/**
 * 懒汉式3-双重检查，只会执行一次同步锁。(这种方式其实还是有问题！引出volatile关键字)
 */

public class Singleton {
    private Singleton() {
    }//私有化构造器

    private static Singleton mInstance;

    public static Singleton getInstance() {
        if (mInstance == null) {
            synchronized (Singleton.class) {
                if (mInstance == null) {
                    mInstance = new Singleton();
                }
            }
        }
        return mInstance;
    }

}

Lazy 初始化：是；
多线程安全：是；
这种方式采用双锁机制，安全且在多线程情况下能保持高性能。
实例变量需要加volatile 关键字保证易变可见性，JDK1.5起才可用，引出下面示例。

单例实现方式5.懒汉式4

/**
 * 懒汉式4-双重检查，只会执行一次同步锁+volatile关键字
 */

public class Singleton {
    private Singleton() {
    }//私有化构造器

    private static volatile Singleton mInstance;

    public static Singleton getInstance() {
        if (mInstance == null) {
            synchronized (Singleton.class) {
                if (mInstance == null) {
                    mInstance = new Singleton();
                }
            }
        }
        return mInstance;
    }

}

volatile关键字讲解

volatile关键字作用

public class TestValatileDemo1 {

    private static class MyRunnable implements Runnable {
        private boolean flag = false;

        @Override
        public void run() {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = true;
            System.out.println("flag = " + flag);
        }

        public boolean isFlag() {
            return flag;
        }
    }

    public static void main(String[] args) throws InterruptedException {

        MyRunnable runnable = new MyRunnable();
        new Thread(runnable).start();

        while (true) {
            if (runnable.isFlag()) {
                System.out.println("----------------");
                break;
            }
        }

    }
}

运行上述代码，控制台输出：

flag = true

只有flag= true，没有分割线输出，且程序没有终止退出。

改动1：如果在while(true)语句块中加入线程休眠：

    public static void main(String[] args) throws InterruptedException {

        MyRunnable runnable = new MyRunnable();
        new Thread(runnable).start();

        while (true) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (runnable.isFlag()) {
                System.out.println("----------------");
                break;
            }
        }

    }

运行上述代码，控制台输出：

flag = true
----------------

Process finished with exit code 0

修改2：去掉上面的线程睡眠，对flag变量加入volatile关键字修饰：

    private static class MyRunnable implements Runnable {
        private volatile boolean flag = false;

        @Override
        public void run() {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = true;
            System.out.println("flag = " + flag);
        }

        public boolean isFlag() {
            return flag;
        }
    }

运行上述代码，控制台输出：

----------------
flag = true

Process finished with exit code 0

小结：

可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。比如：用volatile修饰的变量，就会具有可见性。volatile修饰的变量不允许线程内部缓存和重排序，即直接修改内存。所以对其他线程是可见的。但是这里需要注意一个问题，volatile只能让被他修饰内容具有可见性，但不能保证它具有原子性。比如 volatile int a = 0；之后有一个操作 a++；这个变量a具有可见性，但是a++ 依然是一个非原子操作，也就是这个操作同样存在线程安全问题。

Volatile原理

Java语言提供了一种稍弱的同步机制，即volatile变量，用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。

在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。

Volatile原理.png

当对非 volatile 变量进行读写的时候，每个线程先从内存拷贝变量到CPU缓存中。如果计算机有多个CPU，每个线程可能在不同的CPU上被处理，这意味着每个线程可以拷贝到不同的 CPU cache 中。

而声明变量是 volatile 的，JVM 保证了每次读变量都从内存中读，跳过 CPU cache 这一步。

当一个变量定义为 volatile 之后，将具备两种特性：

1.保证此变量对所有的线程的可见性，这里的“可见性”，如本文开头所述，当一个线程修改了这个变量的值，volatile 保证了新值能立即同步到主内存，以及每次使用前立即从主内存刷新。但普通变量做不到这点，普通变量的值在线程间传递均需要通过主内存（详见：Java内存模型）来完成。

2.禁止指令重排序优化。有volatile修饰的变量，赋值后多执行了一个“load addl $0x0, (%esp)”操作，这个操作相当于一个内存屏障（指令重排序时不能把后面的指令重排序到内存屏障之前的位置），只有一个CPU访问内存时，并不需要内存屏障；（什么是指令重排序：是指CPU采用了允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理）。

volatile 性能：

volatile 的读性能消耗与普通变量几乎相同，但是写操作稍慢，因为它需要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行。

单例实现方式6.静态内部类（也是比较常用，保证了线程安全）

/**
 * 单例实现方式6.静态内部类（也是比较常用，保证了线程安全）
 */

public class Singleton {
    private Singleton() {//私有化构造器
    }

    public static Singleton getInstance() {
        return SingletonHolder.mInstance;
    }

    public static class SingletonHolder {
        private static volatile Singleton mInstance = new Singleton();
    }
}

Lazy 初始化：是；
多线程安全：是；
同样利用了JVM类加载机制来保证初始化实例对象时只有一个线程，静态内部类SingletonHolder 类只有第一次调用 getInstance 方法时，才会装载从而实例化对象。

单例实现方式7.容器管理

/**
 * 单例实现方式7.容器管理
 */

public class Singleton {
    private static Map<String, Object> mSingleMap = new HashMap<>();

    private Singleton() {//私有化构造器
    }

    static {
        mSingleMap.put("SingletonInstance", new Singleton());
    }

    public static Object getInstance(String key) {
        return mSingleMap.get(key);
    }
}

Android中的系统服务中比较常见：

final class SystemServiceRegistry {
    private static final String TAG = "SystemServiceRegistry";

    // Service registry information.
    // This information is never changed once static initialization has completed.
    private static final HashMap<Class<?>, String> SYSTEM_SERVICE_NAMES =
            new HashMap<Class<?>, String>();
    private static final HashMap<String, ServiceFetcher<?>> SYSTEM_SERVICE_FETCHERS =
            new HashMap<String, ServiceFetcher<?>>();
    private static int sServiceCacheSize;

    // Not instantiable.
    private SystemServiceRegistry() { }

    static {
        registerService(Context.ACCESSIBILITY_SERVICE, AccessibilityManager.class,
                new CachedServiceFetcher<AccessibilityManager>() {
            @Override
            public AccessibilityManager createService(ContextImpl ctx) {
                return AccessibilityManager.getInstance(ctx);
            }});
        //....省略....
    }
   public static Object getSystemService(ContextImpl ctx, String name) {
        ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
        return fetcher != null ? fetcher.getService(ctx) : null;
    }

    /**
     * Gets the name of the system-level service that is represented by the specified class.
     */
    public static String getSystemServiceName(Class<?> serviceClass) {
        return SYSTEM_SERVICE_NAMES.get(serviceClass);
    }

    /**
     * Statically registers a system service with the context.
     * This method must be called during static initialization only.
     */
    private static <T> void registerService(String serviceName, Class<T> serviceClass,
            ServiceFetcher<T> serviceFetcher) {
        SYSTEM_SERVICE_NAMES.put(serviceClass, serviceName);
        SYSTEM_SERVICE_FETCHERS.put(serviceName, serviceFetcher);
    }
}

单例实现方式8.单例(《Effective Java》推荐，不常见)

/**
 * 单例实现方式8.枚举
 */

public enum Singleton {
    //定义一个枚举的元素，就代表Singleton实例
    INSTANCE;

    /*
    **假如还定义有下面的方法，调用：Singleton.INSTANCE.doSomethingMethod();
    */
    public void doSomethingMethod() {

    }
}

Lazy 初始化：否；
多线程安全：是；
从Java1.5开始支持enum特性；无偿提供序列化机制，绝对防止多次实例化，即使在面对复杂的序列化或者反射攻击的时候。
不过，用这种方式写不免让人感觉生疏，这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。

开发中常用的几种(前提是必须线程安全)：

  1. 饿汉式——一般情况下都可以使用，最简单，最近本
  2. 静态内部类的方式——需要演示加载的时候使用
  3. 双重检查的锁DCL——面试的时候会问，也是比较常见
  4. 枚举——高安全性的情景下使用

上面8种Java单例模式实现方式除枚举方式外，其他的给实例构造函数protected或private权限，依然可以通过相关反射方法，改变其权限，创建多个实例。

public class Test {
 
    public static void main(String args[]) {
     
        Singleton singleton = Singleton.getInstance();
 
       try {
 
            Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
            constructor.setAccessible(true);
            Singleton singletonnew = constructor.newInstance();
            System.out.println(singleton == singletonnew);
 
        } catch (Exception e) {
 
        }     
    }
}

输出结果：false

可以给构造函数加上判断，限制创建多个实例，如下：

private Singleton() {
 
    if (null != Singleton.singleton) {
 
        throw new RuntimeException();
    }
}

单例模式在Android中的应用场景——Activity的管理类

Activity的管理类可以统一管理Activity的生命周期和操作Activity方法。如A、B、C三个Activity界面，点击C界面一个按钮直接返回到A界面，B界面自动移除的操作。再如单点登录，全局Activity都要弹出一个Dialog提示框的场景。

方案有：
EventBus(纯反射效率低)、广播(有延迟)、集合管理、SingleTask(只适用于部分场景)。

接下来我们写一个Activity管理类来实现上面的场景1.

ActivityManager：

public class ActivityManager {
    String TAG = "ActivityManager";
    private static volatile ActivityManager mInstance;
    private Stack<Activity> mActivities;

    private ActivityManager() {
        mActivities = new Stack<>();
    }

    public static ActivityManager getInstance() {
        if (mInstance == null) {
            synchronized (ActivityManager.class) {
                if (mInstance == null) {
                    mInstance = new ActivityManager();
                }
            }
        }
        return mInstance;
    }

    // 添加Activity
    public void attach(Activity activity) {
        Log.d(TAG, "attach " + activity);
        mActivities.add(activity);
    }

    // 移除Activity
    /*public void detach(Activity target) {
        for (Activity activity : mActivities) {
            if (activity == target) {
                Log.d(TAG, "detach " + activity);
                mActivities.remove(target);//todo 一边循环一边移除是有问题的
            }
        }
    }*/
    // 移除Activity-修改版
    public void detach(Activity target) {
        int size = mActivities.size();
        for (int i = 0; i < size; i++) {
            Activity activity = mActivities.get(i);
            if (activity == target) {
                mActivities.remove(i);
                i--;
                size--;
            }
        }
    }


    // 根据Activity关闭Activity
    /*public void finish(Activity target) {
        for (Activity activity : mActivities) {
            if (activity == target) {
                Log.d(TAG, "detach " + activity);
                mActivities.remove(target);//todo 一边循环一边移除是有问题的
                target.finish();
            }
        }
    }*/

    // 根据Activity关闭Activity-修改版
    public void finish(Activity target) {
        Log.d(TAG, "finish canonicalName:" + target.getClass().getCanonicalName());
        int size = mActivities.size();
        for (int i = 0; i < size; i++) {
            Activity activity = mActivities.get(i);
            if (activity == target) {
                mActivities.remove(i);
                target.finish();
                i--;
                size--;
            }
        }
    }

    // 根据Class关闭Activity
    /*public void finish(Class<? extends Activity> targetClass) {
        Log.d(TAG, "finish canonicalName:" + targetClass.getCanonicalName());
        //com.ivyzh.designpatterndemo.d1_singleton_pattern.activities.BMainActivity
        for (Activity activity : mActivities) {
            if (activity.getClass().getCanonicalName().equals(targetClass.getCanonicalName())) {
                mActivities.remove(activity);//todo 一边循环一边移除是有问题的
                activity.finish();
            }
        }
    }*/

    // 根据Class关闭Activity-修改版
    public void finish(Class<? extends Activity> targetClass) {
        Log.d(TAG, "finish canonicalName:" + targetClass.getCanonicalName());
        //com.ivyzh.designpatterndemo.d1_singleton_pattern.activities.BMainActivity
        int size = mActivities.size();
        for (int i = 0; i < size; i++) {
            Activity activity = mActivities.get(i);
            if (activity.getClass().getCanonicalName().equals(targetClass.getCanonicalName())) {
                mActivities.remove(activity);
                activity.finish();
                i--;
                size--;
            }
        }
    }

    // 退出整个应用
    public void exitApp() {
        int size = mActivities.size();
        for (int i = 0; i < size; i++) {
            Activity activity = mActivities.get(i);
            Log.d(TAG, "exitApp canonicalName:" + activity.getClass().getCanonicalName());
            mActivities.remove(i);
            activity.finish();
            i--;
            size--;
        }
    }

    // 获取当前的Activity，用于全局弹出Dialog
    public Activity currentActivity() {
        return mActivities.lastElement();
    }
}

BaseActivity：

public abstract class BaseActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ActivityManager.getInstance().attach(this);
        setContentView(getContentView());
    }

    protected abstract int getContentView();

    @Override
    protected void onDestroy() {
        ActivityManager.getInstance().detach(this);
        super.onDestroy();
    }
}

A、B、CMainActivity：

public class AMainActivity extends BaseActivity {


    @Override
    protected int getContentView() {
        return R.layout.activity_amain;
    }

    public void click(View v) {
        Intent intent = new Intent(this, BMainActivity.class);
        startActivity(intent);
    }
}

public class BMainActivity extends BaseActivity {


    @Override
    protected int getContentView() {
        return R.layout.activity_bmain;
    }
    public void click(View v) {
        Intent intent = new Intent(this, CMainActivity.class);
        startActivity(intent);
    }
}
public class CMainActivity extends BaseActivity {
    @Override
    protected int getContentView() {
        return R.layout.activity_cmain;
    }

    public void click(View v) {
        ActivityManager.getInstance().finish(this);
        ActivityManager.getInstance().finish(BMainActivity.class);
    }

    public void exit(View v) {
        ActivityManager.getInstance().exitApp();
    }
}

上面的ActivityManager是一个单例，具有获取当前Activty、根据Activity对象或者Class删除Activity、退出应用等功能。

总结：
单例常用实现方式：

1. 饿汉式——一般情况下都可以使用，最简单，最近本
2. 静态内部类的方式——需要演示加载的时候使用
3. 双重检查的锁DCL——面试的时候会问，也是比较常见
4. 枚举——高安全性的情景下使用

END.

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 216,372评论 6赞 498
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,368评论 3赞 392
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 162,415评论 0赞 353
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,157评论 1赞 292
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,171评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,125评论 1赞 297
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,028评论 3赞 417
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,887评论 0赞 274
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,310评论 1赞 310
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,533评论 2赞 332
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,690评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,411评论 5赞 343
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,004评论 3赞 325
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,659评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,812评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,693评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,577评论 2赞 353

推荐阅读更多精彩内容

  • 单例设计模式
    单例模式在我们工作学习和大多数应用中经常碰到。如：Windows的任务管理器（TaskManager）、Windo...
    请叫我张懂阅读 625评论 0赞 2
  • 《Java并发编程的艺术》学习笔记
    本文是我自己在秋招复习时的读书笔记，整理的知识点，也是为了防止忘记，尊重劳动成果，转载注明出处哦！如果你也喜欢，那...
    波波波先森阅读 11,257评论 4赞 56
  • 潜谈单例模式
    单例模式（SingletonPattern）一般被认为是最简单、最易理解的设计模式，也因为它的简洁易懂，是项目中最...
    成热了阅读 4,253评论 4赞 34
  • 失业第二天
    今天是我失业第二天，说到失业并不是被炒鱿鱼而是辞职，辞职的原因就是典型的金牛爆发许许多多的事情积压过后被稻草给压垮...
    木白召召阅读 301评论 0赞 0
  • 12 月第二周总结
    上周一直在学习vba ，但是效果并不好，这次理论上是要开始自己跑程序了，到应该还是差很远，所以，这周需要更用功一点...
    天劫小雨阅读 144评论 0赞 1