《读_Head_First_有感》_“单例模式”

2018-08-14 本文已影响49人 tjhuey

前言：
前沿技术一直在迭代，有一种东西是不会更新的，那就是设计模式的思想。可以来学习学习设计模式的思维，巧妙设计！
单例模式自身的初衷在于应用程序一启动，单例资源一次性永久驻留内存的思想！

[TOC]

1.官方话语

概述

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

六大原则：

单一职责原则（Single ResponsiBility Principle）概括：应该有且仅有一个原因引起类的变更
里氏替换原则（liskov Substitution Principle ）概括：基类出现的地方，子类一定可以出现
依赖倒转原则（Depndece Inversion Principle）概括：针对接口编程，依赖于抽象而不是具体
接口隔离原则（Interface Segregation Principle）概括：使用多个隔离的接口，比使用单个接口好（细分接口，降低耦合）
迪米特法则 (Demeter Principle) 概括：实体应当尽量少的与其他类发生互相作用，使得系统功能模块相对独立
开闭原则（Open Close Principle）概括：对扩展开放，对修改关闭
合成复用原则（Composite Reuse Principle）概括：尽量使用合成/聚合的方式，少用继承

个人话语

概述

设计模式在代码层级中，是让你在某种业务场景刚开始设计时，能让未来的相关需求扩展极为方便的一个思想。
简单的说，在一开始设计好，扩展是很方便的，设计模式就是这个功劳者。
对于我们本来就懒的开发人员来说，这是求之不得的。

六大原则

而对于六大原则，简单过一下就行，不用刻意理解，如果你会了面向对象和设计模式的使用，自然就遵循了。

今日主题

单例模式：概述：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例

场景：

一般单例用途就是用在他的功能，只加载一次就够。比如springmvc的前端控制器，spring的ioc，加载配置文件的配置器类，创建框架内部对象的工厂类，处理日志，缓存，注册表，需要一次性或者独自存在的等。

概述：

代码如下

'单例全部'代码

package top.huey.designpattern.singleton;

/**
 * @author huey
 * @Description :饿汉式
 * 缺点：上来就创建对象，立刻加载，如果我不用getInstance方法的话，那么就浪费了创建所耗的资源。
 * <p>
 * 优点：类属性线程安全，方法不用同步锁也没有并发问题，调用效率高。
 * @Date Created in 2018/8/12 14:59
 */
public class HungryStyle {


    //public Integer number;
    //private Integer number;

    /**
     *       * 类属性，天然线程安全
     * <p>
     *      
     */

    private static HungryStyle hungryStyle = new HungryStyle();

    private HungryStyle() {

    }

    public static HungryStyle getInstance() {

        return hungryStyle;
    }

}

package top.huey.designpattern.singleton;

/**
 * @author huey
 * @Description : * 懒汉式
 * <p>
 * <p>
 * 缺点：由于存在并发问题，需要加上同步锁解决线程安全问题，故调用效率低。
 * <p>
 * 优点：使用的时候再创建，资源利用率高。
 * @Date Created in 2018/8/12 15:01
 */
public class LazyStyle {
    private static LazyStyle lazyStyle;


    private LazyStyle() {

    }

    public synchronized static LazyStyle getInstance() {

        if (lazyStyle == null) {
            //---------------此处如果有多个线程访问，一个线程挂机，当另一个线程进来时，lazyStyle依然为null
            //那么就都去new对象了，失去了初衷（只创建一次），故加上synchronized同步锁
            lazyStyle = new LazyStyle();

        }

        return lazyStyle;

    }
}

package top.huey.designpattern.singleton;

/**
 * @author huey
 * @Description : 静态内部类单例 (书上没有哦)
 * 静态内部类的单例：
 * 优点：高效(不用同步锁) 线程安全（静态类属性） 懒加载（使用时我才创建）
 * @Date Created in 2018/8/12 15:04
 */
public class StaticInnerStyle {

    //静态内部类不会随这类加载而加载，当你调用getInstance方法才会加载该内部类，也就是懒加载
    private static class SingletionClass {
        //类属性，线程安全
        private static final StaticInnerStyle instance = new StaticInnerStyle();
    }

    //不用同步锁，调用效率高
    public static StaticInnerStyle getInstance() {
        return SingletionClass.instance;
    }

    private StaticInnerStyle() {
    }
}

package top.huey.designpattern.singleton;
/**
 * @author huey
 * @Description : 枚举类型的单例模式
 * @Date Created in 2018/8/12 15:06
 */
public enum EnumStyle {

    //枚举天然是单例，jvm的底层实现,不过用枚举实现单例，要求只有这一个对象
    INSTANCE;
    //INSTANCE,SPRING;这样如果测试INSTANCE与SPRING不是通一个对象


    public void service(){
        System.out.println("业务操作....");
    }
    //借助jad工具进行反编译,代码如下
}
/**
 *
 * // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
 // Jad home page: http://www.kpdus.com/jad.html
 // Decompiler options: packimports(3)
 // Source File Name:   EnumStyle.java
 //反编译
 package org.huey.pattern.singleton1;

 import java.io.PrintStream;

 public final class EnumStyle extends Enum
 {

 private EnumStyle(String s, int i)
 {
 super(s, i);
 }

 public void service()
 {
 System.out.println("\u4E1A\u52A1\u64CD\u4F5C....");
 }

 public static EnumStyle[] values()
 {
 EnumStyle aenumstyle[];
 int i;
 EnumStyle aenumstyle1[];
 System.arraycopy(aenumstyle = ENUM$VALUES, 0, aenumstyle1 = new EnumStyle[i = aenumstyle.length], 0, i);
 return aenumstyle1;
 }

 public static EnumStyle valueOf(String s)
 {
 return (EnumStyle)Enum.valueOf(org/huey/pattern/singleton1/EnumStyle, s);
 }

 public static final EnumStyle INSTANCE;
 private static final EnumStyle ENUM$VALUES[];

 static
 {
 INSTANCE = new EnumStyle("INSTANCE", 0);
 ENUM$VALUES = (new EnumStyle[] {
 INSTANCE，
 });
 }
 }
 * */

package top.huey.designpattern.singleton;

/**
 * @author huey
 * @Description : 双重检索 单例， 懒汉式差不多
 * @Date Created in 2018/8/12 15:07
 */
public class DoubleSearchLock {

    private static DoubleSearchLock doubleSearchLock;


    private DoubleSearchLock() {

    }

    /**
     * 懒汉式synchronized 在方法上 实际上多线程情况下就一次使用了，其他时候doubleSearchLock不为null都不存在实际作用
     * 故既浪费资源，又达不到目的，双重检索 是在为null时，加锁，加锁后再判断 不错！ （jdk1.5以上 一般都1.5以上吧）
     */
    public static DoubleSearchLock getInstance() {

        if (doubleSearchLock == null) {

            synchronized (DoubleSearchLock.class) {
                if (doubleSearchLock == null) {
                    doubleSearchLock = new DoubleSearchLock();
                }
            }
        }
        return doubleSearchLock;
    }

}

package top.huey.designpattern.singleton;

import org.junit.Test;

/**
 * @author huey
 * @Description : 单例模式 测试类
 * @Date Created in 2018/8/12 14:55
 */
public class SingletonTest {

    @Test
    public void test1(){
        System.out.println(DoubleSearchLock.getInstance() == DoubleSearchLock.getInstance());
        System.out.println(EnumStyle.INSTANCE == EnumStyle.INSTANCE);
        System.out.println(HungryStyle.getInstance() == HungryStyle.getInstance());
        System.out.println(LazyStyle.getInstance() == LazyStyle.getInstance());
        System.out.println(StaticInnerStyle.getInstance() == StaticInnerStyle.getInstance());

    }
}

读者须知：

1.本系列文章内容会比较简陋，望有兴趣读者还是fork源码，调试一下。（如果你看过该书，一定可以加深印象）
2.联想下实际运用的哪些业务场景用到该模式，哪些中间件用到该模式，是否自己能在业务中使用。
3.即使你现在用不到某些设计模式，但是还是应该理解其原理的。
4.当时理解并不意味着自己已会，可以自己尝试练习，并幻想一种业务场景，画画类图，设计一下。

coding 时，做到了如何落实;
writing时，做到了如何表达;
sharing时，做到了如何传授;
thinking时，做到了如何提升;

代码请参考码云:https://gitee.com/tjhuey/CodingGroup
设计模式相关概念请参考:http://naotu.baidu.com/file/5811bf42020e6a2d877b992cfca90d26

进度

[x] 策略模式，已完成
[x] 观察者模式，已完成;
[x] 装饰者模式，已完成;
[x] 工厂方法模式，已完成;
[x] 抽象工厂模式，已完成;
[x] 单例模式，已完成;
[ ] ..，未完成;