你敢说本身了解单例模式?

时间 2020-08-21

标签敢说本身了解模式繁體版

原文原文链接

1、背景

　　最近在学习设计模式，在看到单例模式的时候，我一开始觉得直接很了解单例模式了，实现起来也很简单，可是实际上单例模式有着好几个变种，而且多线程中涉及到线程安全问题，那么本文咱们就来好好聊聊单例模式，说一下经典三种实现方式：饿汉式、懒汉式、登记式。而且解决掉多线程中可能出现的线程安全问题。java

2、基本概念

1.为何要使用单例模式？数据库

　　在咱们平常的工做中，不少对象一般占用很是重要的系统资源，好比：IO处理，数据库操做等，那咱们必需要限制这些对象只有且始终使用一个公用的实例，即单例。设计模式

2.单例模式的实现方式安全

构造函数私有化，防止其余类生成惟一公用实例外的实例。且
单例类应该被定义为final，也就是说单例类不能被继承，由于若是容许继承那子类就均可以建立实例，违背了类惟一实例的初衷。
类中一个静态变量来保存单实例的引用。
一个共有的静态方法来获取单实例的引用。

3.单例模式的UML类图多线程

4.单例模式的经典实现方式函数

饿汉式：一开始就建立好实例，每次调用直接返回，经典的“拿空间换时间”。
懒汉式：延迟加载，第一次调用的时候才加载，而后返回，之后的每次的调用就直接返回。经典“拿时间换空间”,多线程环境下要注意解决线程安全的问题。
登记式：对一组单例模式进行的维护，主要是在数量上的扩展，经过线程安全的map把单例存进去，这样在调用时，先判断该单例是否已经建立，是的话直接返回，不是的话建立一个登记到map中，再返回。

3、饿汉式---代码实现

1.单例类单元测试

package com.hafiz.designPattern.singleton;

/**
 * Desc: 单例模式-饿汉式
 * Created by hafiz.zhang on 2017/9/26.
 */
public class Singleton1 {

    // 建立全局静态变量，保证只有一个实例
    private static volatile Singleton1 instance  = new Singleton1();

    private Singleton1() {
        // 构造函数私有化
        System.out.println("--调用饿汉式单例模式的构造函数--");
    }

    public static Singleton1 getInstance() {
        System.out.println("--调用饿汉式单例模式的静态方法返回实例--");
        return instance;
    }
}

2.测试类学习

public class DesignPatternTest {

    @Test
    public void testSingleton1() {
        System.out.println("-----------------测试饿汉式单例模式开始--------------");
        Singleton1 instance1 = Singleton1.getInstance();
        System.out.println("第二次获取实例");
        Singleton1 instance2 = Singleton1.getInstance();
        System.out.println("instance1和instance2是否为同一实例?" + (instance1 == instance2));
        System.out.println("-----------------测试饿汉式单例模式结束--------------");
    }
}

3.测试结果测试

4、懒汉式---代码实现

1.单例类spa

package com.hafiz.designPattern.singleton;

/**
 * Desc:单例模式-懒汉式
 * Created by hafiz.zhang on 2017/9/26.
 */
public class Singleton2 {

    // 建立全局静态变量，保证只有一个实例
    private static Singleton2 instance = null;

    // 构造函数私有化
    private Singleton2() {
        System.out.println("--调用懒汉式单例模式的构造方法--");
    }

    public static Singleton2 getInstance() {
        System.out.println("--调用懒汉式单例模式获取实例--");
        if (instance == null) {
            System.out.println("--懒汉式单例实例未建立,先建立再返回--");
            instance = new Singleton2();
        }
        return instance;
    }
}

2.测试类

public class DesignPatternTest {

    @Test
    public void testSingleton2() {
        System.out.println("-----------------测试懒汉式单例模式开始--------------");
        Singleton2 instance1 = Singleton2.getInstance();
        System.out.println("第二次获取实例");
        Singleton2 instance2 = Singleton2.getInstance();
        System.out.println("instance1和instance2是否为同一实例?" + (instance1 == instance2));
        System.out.println("-----------------测试懒汉式单例模式结束--------------");
    }
}

3.测试结果

细心的同窗已经发现，这种实现方式，在多线程的环境中，是有线程安全安全问题的，有可能两个或多个线程判断instance都为null,而后建立了好几遍实例，不符合单例的思想，咱们能够对它进行改进。

5、改进懒汉式1---代码实现

原理：使用JDK的synchronized同步代码块来解决懒汉式线程安全问题。

1.单例类

package com.hafiz.designPattern.singleton;

/**
 * Desc:单例模式-懒汉式
 * Created by hafiz.zhang on 2017/9/26.
 */
public class Singleton2 {

    // 建立全局静态变量，保证只有一个实例
    private static Singleton2 instance = null;

    // 构造函数私有化
    private Singleton2() {
        System.out.println("--调用懒汉式单例模式的构造方法--");
    }

    public static Singleton2 getInstance() {
        System.out.println("--调用懒汉式单例模式获取实例--");
　　　　　if (instance != null) {
　　　　　　　　System.out.println("--懒汉式单例实例已经建立,直接返回--");
            　return instance;
　　　　　}
        synchronized (Singleton2.class) {
        　　 if (instance == null) {
            　　System.out.println("--懒汉式单例实例未建立,先建立再返回--");
            　　instance = new Singleton2();
        　　 }
        }
        return instance;
    }
}

2.测试结果

6、改进懒汉式2---代码实现

原理：使用JVM隐含的同步和类级内部类来解决，JVM隐含的同步解决了多线程状况下线程安全的问题，类级内部类解决只有使用的时候才加载（延迟加载）的问题。

1.JVM隐含的同步有哪些？

静态初始化器(在静态字段上或static{}静态代码块的初始化器)初始化数据时
访问final字段时
在建立线程以前建立对象时
线程能够看见它将要处理的对象时

2.什么是类级内部类？

有static修饰的成员式内部类。没有static修饰的成员式内部类叫对象级内部类。
类级内部类至关于其外部类的static成分，他的对象与外部类对象间不存在依赖关系，所以可直接建立，而对象级内部类的实例，是绑定在外部对象实例中的。
类级内部类中，能够定义静态的方法。在静态的方法中只可以引用外部类的中的静态成员方法或者成员变量
类级内部类至关于其外部类的成员，只有在第一次被使用的时候才会被装载

3.单例类

package com.hafiz.designPattern.singleton;

/**
 * Desc:单例模式-改进懒汉式
 * Created by hafiz.zhang on 2017/9/26.
 */
public class Singleton3 {
    private static class Singleton4 {
        private static Singleton3 instance;
        static {
            System.out.println("--类级内部类被加载--");
            instance = new Singleton3();
        }
        private Singleton4() {
            System.out.println("--调用类级内部类的构造函数--");
        }
    }
    private Singleton3() {
        System.out.println("--调用构造函数--");
    }
    public static Singleton3 getInstance() {
        System.out.println("--开始调用共有方法返回实例--");
        Singleton3 instance;
        System.out.println("---------------------------");
        instance = Singleton4.instance;
        System.out.println("返回单例");
        return instance;
    }
}

4.测试类

package com.hafiz.www;

import com.hafiz.designPattern.observer.ConcreteObserver;
import com.hafiz.designPattern.observer.ConcreteSubject;
import com.hafiz.designPattern.singleton.Singleton1;
import com.hafiz.designPattern.singleton.Singleton2;
import com.hafiz.designPattern.singleton.Singleton3;
import com.hafiz.designPattern.singleton.Singleton4;
import com.hafiz.designPattern.singleton.Singleton4Child1;
import com.hafiz.designPattern.singleton.SingletonChild2;
import org.junit.Test;

/**
 * Desc:设计模式demo单元测试类
 * Created by hafiz.zhang on 2017/7/27.
 */
public class DesignPatternTest {

    @Test
    public void testSingleton3() {
        System.out.println("-----------------测试改进懒汉式单例模式开始--------------");
        Singleton3 instance1 = Singleton3.getInstance();
        System.out.println("第二次获取实例");
        Singleton3 instance2 = Singleton3.getInstance();
        System.out.println("instance1和instance2是否为同一实例?" + (instance1 == instance2));
        System.out.println("-----------------测试改进懒汉式单例模式结束--------------");
    }
}

5.测试结果

7、登记式--代码实现

1.基类

package com.hafiz.designPattern.singleton;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Desc: 单例模式-登记式
 * Created by hafiz.zhang on 2017/9/26.
 */
public class Singleton4 {

    private static Map<String, Singleton4> map = new ConcurrentHashMap<>();

    protected Singleton4() {
        System.out.println("--私有化构造函数被调用--");
    }

    public static Singleton4 getInstance(String name) {
        if (name == null) {
            name = Singleton4.class.getName();
            System.out.println("--name为空，默认赋值为：--" + Singleton4.class.getName());
        }
        if (map.get(name) != null) {
            System.out.println("name对应的值存在，直接返回");
            return map.get(name);
        }
        System.out.println("name对应的值不存在，先建立，再返回");
        try {
            Singleton4 result = (Singleton4)Class.forName(name).newInstance();
            map.put(name, result);
            return result;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    public Map<String, Singleton4> getMap() {
        return map;
    }
}

2.子类1

package com.hafiz.designPattern.singleton;

/**
 * Desc:
 * Created by hafiz.zhang on 2017/9/26.
 */
public class Singleton4Child1 extends Singleton4 {

    public static Singleton4Child1 getInstance() {
        return (Singleton4Child1) Singleton4.getInstance("com.hafiz.designPattern.singleton.Singleton4Child1");
    }
}

3.子类2

package com.hafiz.designPattern.singleton;

/**
 * Desc:
 * Created by hafiz.zhang on 2017/9/26.
 */
public class SingletonChild2 extends Singleton4 {

    public static SingletonChild2 getInstance() {
        return (SingletonChild2) Singleton4.getInstance("com.hafiz.designPattern.singleton.SingletonChild2");
    }
}

4.测试类

public class DesignPatternTest {

    @Test
    public void testSingleton4() {
        System.out.println("-----------------测试登记式单例模式开始--------------");
        System.out.println("第一次取得实例");
        Singleton4 instance1 = Singleton4.getInstance(null);
        System.out.println("res:" + instance1);
        System.out.println("第二次获取实例");
        Singleton4Child1 instance2 = Singleton4Child1.getInstance();
        System.out.println("res:" + instance2);
        System.out.println("第三次获取实例");
        SingletonChild2 instance3 = SingletonChild2.getInstance();
        System.out.println("res:" + instance3);
        System.out.println("第四次获取实例");
        SingletonChild2 instance4 = new SingletonChild2();
        System.out.println("res:" + instance4);
        System.out.println("输出父类Map中全部的单例");
        Map<String, Singleton4> map = instance1.getMap();
        for (Map.Entry<String, Singleton4> item : map.entrySet()) {
            System.out.println("map-item:" + item.getKey() + "=" + item.getValue());
        }
        System.out.println("instance1和instance2是否为同一实例?" + (instance1 == instance2));
        System.out.println("-----------------测试登记式单例模式结束--------------");
    }
}

5.测试结果

该解决方案的缺点：基类的构造函数对子类公开了(protected),有好的解决方案的博友能够讨论指教~

8、总结

　　通过本文，咱们就搞明白了什么叫单例模式，如何优雅的实现经典的单例模式，如何进行拓展和开发具备线程安全的单例模式。对于咱们之后的开发很是有帮助，也让咱们更加了解单例模式。