Designer Watches: 23种设计模式入门 -

2021-01-05

23种设计模式入门 -

单例模式：采用一定的方法，使得软件运行中，对于某个类只能存在一个实例对象，并且该类只能提供一个取得实例的方法。

分类：

饿汉式
1. 静态常量方式
2. 静态代码块方式
懒汉式
1. 普通方式，线程不安全
2. 同步方法方式，线程安全
3. 同步代码块方式，线程不安全
其他方式
1. 双重检查
2. 静态内部类
3. 枚举

实现思路：

想要实现单例，即不能让外部随意的去实例化对象。所以需要构造器私有
既然不允许外部去创建了，所以需要在类的内部创建对象
外部需要使用对象，所以需要对外提供一个获取实例的方法

一、饿汉式

根据对象创建的时机，可以分为饿汉式和懒汉式。饿汉式，即在类加载的时候立即创建实例，根据所学知识我们可以很快想到要使用static关键字将属性和类相关联。以下提供两种书写方式供参考。

特点

优点：写法简单，在类装载的时候就完成实例化，避免了线程同步问题
缺点：在类装载的时候就完成了实例化，如果开始至终都没有使用这个实例，会造成内存浪费

1.静态常量方式

class Singleton01{ //构造器私有，防止外部new private Singleton01(){ } //内部创建对象 private final static Singleton01 instance = new Singleton01(); //提供给外部创建实例的静态方法 public static Singleton01 getInstance(){  return instance; }}

2.静态代码块方式

class Singleton02{ //构造器私有，防止外部new private Singleton02(){ } //内部创建对象 private static Singleton02 instance; static {  instance = new Singleton02(); } //提供给外部创建实例的静态方法 public static Singleton02 getInstance(){  return instance; }}

这种方式和静态常量的实现方式逻辑和优缺点是一样的，只是写法不同。

二、懒汉式

懒汉式，即在类加载时并不实例化对象，等到使用对象实例的时候才去实例化，也被称为懒加载效果。这样做的好处可以节约资源，减少浪费，只有需要的时候采取创建，不需要就不会实例化。

1.普通方式（线程不安全）

class Singleton01{ // 构造器私有 private Singleton01(){ } // 定义静态变量，实例化留在获取实例的getInstance方法，起到懒加载效果 private static Singleton01 instance; public static Singleton01 getInstance(){  // 判断如果为空才创建，起到懒加载  if (instance == null){   instance = new Singleton01();  }  return instance; }}

问题：在多线程情况下，假设类还未第一次实例化，此时两个进程同时执行到了if(instance==null)，而未来得及往下执行时，此时两者校验都成立，都会执行实例化操作，将有可能出现创建多个实例的问题。

2.同步方法方式（线程安全）

既然存在线程安全问题，肯定会想到使用synchronized关键字来解决

class Singleton02{ private static Singleton02 instance; private Singleton02(){ } //使用synchronized关键字来实现线程安全 public static synchronized Singleton02 getInstance(){  if (instance == null){   instance = new Singleton02();  }  return instance; }}

这样的方式可以起到线程安全的效果，但是每个线程都需要等待锁，所以又会存在效率低的问题，于是有人想到了将锁的范围缩小到方法的内部，使用同步代码块的方式

3.同步代码块方式（线程不安全）

这样的方式好不好呢？先看代码

class Singleton03{ private static Singleton03 instance; private Singleton03(){ } public static Singleton03 getInstance(){  if (instance == null){   // 这里的synchronized其实没有实际意义，可能会产生多个实例   synchronized (Singleton03.class){     instance = new Singleton03();   }  }  return instance; }}

这样锁的范围是变小了，但是还会存在多个线程同时判断到if (instance == null)，即使在后面加上锁，依旧会在后续创建实例，只是延迟了一点而已，所以这种写法不可取

三、其他方式

1.双重检查

为了能够实现懒加载的效果，同时兼顾效率，于是出现了这种写法

class Singleton01{ //volatile，当有发生变化时即时储存到内存中。防止指令重排 private static volatile Singleton01 instance; private Singleton01(){ } //双重检查，解决线程同步问题，又保证效率 public static Singleton01 getInstance(){  if (instance == null){ // 第一次检查，降低产生锁的概率   synchronized (Singleton01.class){    if(instance == null){ // 第二次检查，保证线程安全     instance = new Singleton01();    }   }  }  return instance; }}

使用双重检查，第一次检查提升效率，第二次检查保证线程安全，简直美滋滋

2.静态内部类

利用静态内部类在被调用时才会加载，即存在懒加载效果，所以也可以这样写

class Singleton02{ private Singleton02(){ } /*  静态内部类在外部类装载的时候不会马上执行，起到懒加载作用。  类的静态属性只有在第一次使用的时候才会加载，JVM在类加载时是线程安全的  */ private static class SingletonInstance{  private static final Singleton02 INSTANCE = new Singleton02(); } public static Singleton02 getInstance(){  return SingletonInstance.INSTANCE; }}

3.枚举

枚举方式是最简单的写法，也是被很多人推崇的写法

enum Singleton03{ INSTANCE;}

简单明了...

四、小结

使用单例模式，可以使一个类只存在一个实例对象，从而节省了系统资源。

上文中列出了8个写法，其中懒加载的写法存在线程安全和效率的问题，需要谨慎使用。比较推荐的写法有5种：懒加载2种+其他方式3种。当认定单例的对象在软件中一定会用到，可以使用懒加载，反之可以使用其他方式

原文转载：http://www.shaoqun.com/a/505920.html

跨境电商：https://www.ikjzd.com/

打折网站：https://www.ikjzd.com/w/74

淘粉吧：https://www.ikjzd.com/w/1725

单例模式：采用一定的方法，使得软件运行中，对于某个类只能存在一个实例对象，并且该类只能提供一个取得实例的方法。分类：饿汉式静态常量方式静态代码块方式懒汉式普通方式，线程不安全同步方法方式，线程安全同步代码块方式，线程不安全其他方式双重检查静态内部类枚举实现思路：想要实现单例，即不能让外部随意的去实例化对象。所以需要构造器私有既然不允许外部去创建了，所以需要在类的内部创建对象外部需要使用对象，所以需
cima：cima
bol：bol
去想去的地方爱上这3天的日与夜：去想去的地方爱上这3天的日与夜
广州图书馆在哪里？什么时候开放？：广州图书馆在哪里？什么时候开放？
阿里Q2财报：跨境及全球零售商业收入同比增长30%：阿里Q2财报：跨境及全球零售商业收入同比增长30%

Designer Watches