前言：
前沿技术一直在迭代，有一种东西是不会更新的，那就是设计模式的思想。 可以来学习学习设计模式的思维，巧妙设计！
单例模式自身的初衷在于应用程序一启动，单例资源一次性永久驻留内存的思想！
[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]
策略模式，<span style="color: #43A047; ">已完成</span> - [x]
观察者模式，<span style="color: #43A047; ">已完成</span>; - [x]
装饰者模式，<span style="color: #43A047; ">已完成</span>; - [x]
工厂方法模式，<span style="color: #43A047; ">已完成</span>; - [x]
抽象工厂模式，<span style="color: #43A047; ">已完成</span>; - [x]
单例模式，<span style="color: #43A047; ">已完成</span>; - [ ]
..，<span style="color: #F44336; ">未完成</span>;
