Java之设计模式总结(主要是单例设计模式)

，一、设计模式（Design Patterns）简介

设计模式由国外GOF（Group of four即“四人帮”）总结。共有23种。设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。

二、设计模式的作用

1、使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。
2、项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因

三、设计模式的分类

1、创建模式
——单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式
2、原型模式
——适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
3、行为模式
——模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式

四、重点掌握——单例模式

我个人一直觉得学习编程其实和写文章是一个道理，而设计模式就是我们写文章所对应的套路 。比如三段式、两点论等等。
当然对于我们初学者来说，还只是识字阶段，所以先来个单例模式尝尝鲜，其他的模式在以后开发中，也会慢慢接触到。

1、单例模式的核心作用
——保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
2、单例模式的优点
——由于单例模式只生成一个实例，减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如：读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例的对象然后永久驻留内存的方式来解决。
——单例模式可以在系统设置全局的访问点，优化环共享资源的人访问，例如设计一个单例类，负责所有数据表的映射处理。
3、实现单例模式的几种方法
（1）饿汉式（线程安全、调用效率高，但是不能延时加载（也可以说成懒加载））
（2）懒汉式（线程安全、调用效率不高，但是可以延时加载）
（3）双重检测锁式（综合上述两个的优点，但是由于JVM底层内部模型原因，偶尔会出问题，不建议使用）
（4）静态内部类（线程安全，调用效率高，但是可以延时加载）
（5）枚举制（线程安全，调用效率高，不能延时加载）

4、如何选用

——单例对象 占用资源少，不需要延时加载：
枚举式 好于饿汉式
——单例对象 占用资源大 需要延时加载：
静态内部类好于懒汉式

5、常见的五种单例模式在多线程环境下的效率测试
（只关注相对值，在不同的环境下不同的程序测得的值完全不一样）
1. 饿汉式 22ms
2. 懒汉式 636ms
3. 静态内部类式 28ms
4. 枚举制 32ms
5. s双重检索机制 65ms

6、具体代码实现

（1）、懒汉式：

**
 * 饿汉式实现单例设计模式
 * @author 虎
 *
 */
public class EagerSingleton {
    //类初始化时，立即加载这个对象（没有延时加载的优势）。加载类时，天然的是线程安全的
    private static EagerSingleton instance =  new EagerSingleton();

    private EagerSingleton() {
    }

    public static EagerSingleton getInstance () {
        return instance;
    }

}

（2）、懒汉式：

package com.sxt.singleton;
/** * 懒汉式实现单例设计模式 * @author 代虎 * */
public class LazySingleton {
   
    //类初始化时，不初始化这个对象（延时加载，真正用到的时候载创建）
    private static LazySingleton instance;

    private LazySingleton() {

    }
    //方法同步，调用效率低
    public static synchronized LazySingleton getInstance() {
        if(null == instance) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

（3）、双重检索锁

package com.sxt.singleton;
/** * 双重检测所实现单例模式 * 使用了volatile关键字修饰，阻止了变量访问前后的指令重排，保证了指令执行的顺序 * @author 代虎 * */
public class DoubleCheckLocking {
   

    private volatile static DoubleCheckLocking instance;

    private DoubleCheckLocking() {
    }

    public  static DoubleCheckLocking getInstance () {
        if(null == instance)  {
  //双重检测机制
            synchronized (DoubleCheckLocking.class) {
  //同步锁
                if(null == instance) {
  //双重检测机制
                    instance = new DoubleCheckLocking();
                }
            }
        }
        return instance ;
    }

}

（4）、静态内部类

package com.sxt.singleton;
/** * 测试静态内部类实现单例模式 * 这种方式，线程安全,调用效率高，并且实现了延时加载。 * @author 代虎 * */
public class StaticInnerClasses {
   

    public StaticInnerClasses() {
    }

    private static class InnerClass {
   
        private static final StaticInnerClasses instance = new StaticInnerClasses();
    } 
    //方法没有同步，调用效率高
    public static StaticInnerClasses getInstance() {
        return InnerClass.instance;
    }
}

（5）、枚举制

package com.sxt.singleton;
/** * 通过枚举式实现单例模式（没有延时加载） * @author 代虎 * */
public enum EnumMethod {

    //这个枚举元素，本身就是单例对象！
    INSTANCE;

    //添加自己需要的操作
    public void singletonOperation() {

    }
}