设计模式-单例模式

Anymarvel

发布于 2018-10-22 11:12:49

3790

发布于 2018-10-22 11:12:49

文章被收录于专栏：Android开发实战

以最简单的module学习设计模式，理解最重要连着更了几天，今天写个简单的，单例模式

前言

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例。 3、单例类必须给所有其他对象提供这一实例。

正文：

注:由于单例模式是经常用到的，这里就不提供demo了（懒。。。）本文就总结了Java中单例模式的几种实现方式，并比较了它们的优缺点

1. 最简单的实现---饿汉式

Java

/**
 * 饿汉式
 */public class Single {    private static Single single = new Single();    private Single() {    }    public static Single getInstance() {        return single;    }
}

写一个单例（不管什么形式），主要注意点如下几点(该种方式不存在线程安全的问题，其是线程安全的)

成员变量 single 要声明成静态的（static），因为需要在静态方法getInstance()中访问；
构造方法要声明成私有，不然如何保证单例；
getInstance()要声明成 public static的。

Kotlin

/**
 * 饿汉式
 */object Single {
}

有童鞋要说了，这什么都没写呀。对，饿汉式在Kotlin中，只需要一个object修饰符就行了，这就是Kotlin非常厉害的地方。

2.性能优化（lazy load）——懒汉式

饿汉式的方式虽然简单，但是是基于classloader加载的，其在该类第一次加载进内存时就会初始化单例对象。这样，无论该对象是否被使用，都会创建一个single对象。

Java

/**
 * 懒汉式 --- 非线程安全
 */public class Single {    private static Single single;    private Single() {    }    public static Single getInstance() {        if (single == null) {            single = new Single();        }        return single;    }
}

Kotlin

/**
* 懒汉式 --- 非线程安全
*/class Single private constructor() {
  companion object {      /**
       * Kotlin原生写法
       */
      val INSTANCL_1 by lazy(LazyThreadSafetyMode.NONE) {
          Single()
      }      /**
       * 翻译java的写法
       */
      private var single: Single? = null      fun getInstance(): Single {          if (single == null) {              single = Single()          }          return single!!      }

  }
}

Kotlin这里有两种写法，一种是纯种，一种是变种。变种大家一看就明白，就是直接把Java的方式翻译过来了。纯种的我们使用了lazy，看英文就知道是懒加载的方式，传入了一个LazyThreadSafetyMode.NONE，英文好的小伙伴一看就明白，这是线程不安全的意思。companion object的意思相当于Java中public static。

3. 懒汉式——线程安全（1）

因为懒汉式的出现，虽然解决了饿汉式的不足，但也出现了多线程的问题。于是解决懒汉式的方式就出现了，那就是我们熟知的加锁Synchronized。 Java

/**
 * 懒汉式 --- 线程安全
 * 使用synchronized保证线程安全
 * 虽然线程安全了,但因为使用synchronized关键字使加锁效率不高 */public class Single {    private static Single instance;    private Single() {    }    public static synchronized Single getInstance() {        if (instance == null) {            instance = new Single();        }        return instance;    }
}

Kotlin

/**
 * 懒汉式 --- 线程安全
 * 使用synchronized保证线程安全
 * 虽然线程安全了,但因为使用synchronized关键字使加锁效率不高
 * Kotlin使用@Synchronized注解加锁
 */class Single private constructor() {    companion object {        private var single: Single? = null
        @Synchronized        fun getInstance(): Single {            if (single == null) {                single = Single()            }            return single!!        }
    }

}

4. 懒汉式——线程安全（2）：效率更高

Java

/**
 * 懒汉式 --- 线程安全 双重校验锁 */public class Single {    private static Single single;   private Single() {    }    public static Single getInstance() {        if (single == null) {            synchronized (Single.class) {                if (single == null) {                    single = new Single();
                }
            }        }        return single;    }

}

但是上面的单例都有其缺陷：当反序列化和使用java的反射机制时，单例无法得到保证，那么，解决该问题，我们可以使用Enum（枚举）。 Kotlin

/**
 * 懒汉式 --- 线程安全 双重校验锁
 */class Single private constructor() {

    companion object {        /**
         * Kotlin原生写法
         */
        val INSTANCE_1 by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            Single()
        }        /**
         * 翻译java写法(变种方法)
         */
       private var single: Single? = null        fun getInstance(): Single {            if (single == null) {                synchronized(Single::class.java) {                    if (single == null) {                        single = Single()
                    }
                }            }            return single!!        }
    }

}

Kotlin原生的，我们只改变了lazy的括号的值，mode = LazyThreadSafetyMode.SYNCHRONIZED就是锁的意思，英文好的童鞋一眼就明白了。

5. 枚举实现

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化和反射机制重新创建新的对象，不过，JDK1.5中才加入enum特性，这种方式只能在1.5之后使用。(但是Android官网不建议使用enums，占用内存多（Enums often require more than twice as much memory as static constants.）) Java

/**
 * 枚举实现
 */public enum Single {    INSTANCE;    public void method() {    }
}

Kotlin

/**
 * 枚举实现
 */public enum Single {    INSTANCE;    public void method() {    }
}

6.内部类式

虽然不怎么被大家使用，但是觉得还是比较好。还是要说一下的 Java

/**
 * 内部类实现
 */public class Single {
    private Single() {    }    private static class Hodler {        private static Single single = new Single();    }    public static Single getInstance() {        return Hodler.single;    }
}

内部类Holder，里面有外部的实例。很多童鞋可能要问，这怎么就满足懒汉式和线程安全呢？当我们应用初始化时，getInstance没有被调用，就没有实例对象，那就满足了懒汉式。当我们调用getInstance的时候，Java虚拟机为了保证类加载的安全性，所以这里就保证了线程安全。这种写法是不是惊呆了？那Kotlin又是怎么样写的呢？

/**
 * 内部类实现
 */class Single private constructor() {    companion object {        fun getInstance(): Single {            return Hodler.single        }    }    private object Hodler {        val single = Single()
    }
}

很简单，内部用object创建一个内部Holder单例，外部一个getInstance来获取的方法。也相当于是Java翻译过来的方式。

设计模式持续更新中:https://www.jianshu.com/p/e3c25095c31f

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2018-06-08，如有侵权请联系 cloudcommunity@tencent.com 删除

面向对象编程

本文分享自 Android历练记微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

面向对象编程

登录后参与评论

0 条评论

热度