前言

掌握设计模式的层次

  1. 刚开始学编程不久,听说过什么是设计模式
  2. 由很长时间的编程经验,自己写了很多代码,其中用到了设计模式,但是自己却不知道
  3. 学习过了设计模式,发现自己已经在使用了,并且发现了一些新的模式挺好用的
  4. 阅读了很多别人写的源码和框架,在其中看到别人设计模式,并且能够领会设计模式的精妙和带来的好处。
  5. 代码写着写着,字节都没有意识到使用了设计模式,并且熟练的写了出来。

设计模式介绍

  1. 设计模式是程序员再面对同类软件工程设计问题所总结出来的有用的经验,模式不是代码,而是 某类问题的通用解决方案,设计模式(Design pattern)代表了最佳的实践。这些解决方案是众多软件开发人员经过相当长的时间的试验和错误总结出来的。
  2. 设计模式的本质提高软件的维护性,通用性和扩展性,并降低软件的复杂度。

设计模式分为三种类型,共23种

  1. 创建型模式:单例模式,抽象工厂模式,原型模式,建造者模式,工程模式。

  2. 结构型模式:适配器模式,桥接模式,装饰模式,组合模式,外观模式,享元模式,代理模式

  3. 行为型模式:模块方法模式,命令模式,访问者模式,迭代模式,观察者模式,中介者模式,备忘录模式,解释器模式(Interpreter模式),状态模式,策略模式,职责链模式(责任链模式)

    注意:不同的书籍上对分类和名称略有差别。

单例模式

  • 单例模式介绍

    ​ 所谓类的单例设计模式,就是采取一定的方法保证再整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供了一个取得对象实例的方法(静态方法)。

    ​ 比如Hibernate的SessionFactory,他充当数据存储源的代理,并负责创建Session对象。SessionFactory并不是轻量级的,一般情况下,一个项目通常只需要一个SessionFactoury就够,这是就会用到单例模式。

  • 单例设计模式有八种写法

    1. 饿汉式(静态常量)
    2. 饿汉式(静态代码块)
    3. 懒汉式(线程不安全)
    4. 懒汉式(线程安全,同步方法)
    5. 懒汉式(线程安全,同步代码块)
    6. 双重检查
    7. 静态内部类
    8. 枚举
  • 饿汉式(静态常量)

    • 步骤如下:
    1. 构造器私有化(防止 new)

    2. 类的内部创建对象

    3. 向外暴露一个静态的公共方法。gentInstance

    4. 代码实现

      public class SingletonTest1 {
         public static void main(String[] args) {
             //测试
             Singleton instance = Singleton.getInstance();
             Singleton instance1 = Singleton.getInstance();
             System.out.println(instance == instance1);//true
             System.out.println("instance.hashCode=" + instance.hashCode());//1163157884
             System.out.println("instance1.hashCode=" + instance1.hashCode());//1163157884
         }
      }
      
      //饿汉式(静态变量)
      class Singleton {
         //1. 私有化构造器,外部不能能new
         private Singleton() {}
         //2. 在本类内部创建对象实例
         private final static Singleton instance = new Singleton();
         //3. 提供一个共有的静态方法,返回实例对象
         public static Singleton getInstance() {
             return instance;
         }
      }
    • 优缺点说明

      1. 优点;这种写法比较简单,就是再类装载的时候就完成实例化。避免了线程同步问题。
      2. 缺点;再类装载的时候就完成实例化,没有达到Lazy Loading(懒加载)的效果。如果从始至终从未使用这个实例,则会造成内存的浪费。
      3. 这种方法基于classloder机制避免了多线程的同步问题,不过,instance再类装载时就实例化,再单例模式种大多数都是调用getInstance方法,但是导致类装载的原因有很多种,因此不能确定其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance就没有达到lazy loading的效果
      4. 结论;这种单例模式可用,可能造成内存浪费。
    • 饿汉式(静态代码块)

    • 代码

      public class SingletonTest2 {
        public static void main(String[] args) {
            //测试
            Singleton instance = Singleton.getInstance();
            Singleton instance1 = Singleton.getInstance();
            System.out.println(instance == instance1);//true
            System.out.println("instance.hashCode=" + instance.hashCode());//1163157884
            System.out.println("instance1.hashCode=" + instance1.hashCode());//1163157884
        }
      }
      
      //饿汉式(静态变量)
      class Singleton {
        //1. 私有化构造器,外部不能能new
        private Singleton() { }
        //2. 在本类内部创建对象实例
        private static Singleton instance;
        //在静态代码块中,创建对象
        static { instance = new Singleton(); }
        //3. 提供一个共有的静态方法,返回实例对象
        public static Singleton getInstance() {
            return instance;
        }
      }
    • 优缺点说明

      1. 这种方式和上面的方式其实类似,只不过将类实例的过程放在了静态代码块中,也是再类装载的时候,就执行静态代码块中的代码,初始化类的实例。优缺点和上面是一样的。
      2. 结论;这种单例模式可用,但是可能造成内存浪费。
    • 懒汉式(线程不安全)

    • 代码

      public class SingletonTest03 {
        public static void main(String[] args) {
            //测试
            System.out.println("懒汉式1,线程不安全");
            Singleton instance = Singleton.getInstance();
            Singleton instance1 = Singleton.getInstance();
            System.out.println(instance == instance1);//true
            System.out.println("instance.hashCode=" + instance.hashCode());//1163157884
            System.out.println("instance1.hashCode=" + instance1.hashCode());//1163157884
        }
      }
      
      class Singleton {
        private static Singleton instance;
        public Singleton() { }
        //提供一个静态的共有方法,当使用该方法时,才去创建instance
        //即懒汉式
        public static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
      }
    • 优点说明
    1. 起到Lazy Loading的效果,但是只能再单线程下使用。
    2. 如果再多线程下,一个线程进入if(singlenton == null) 判断语句块,还未来得及往下执行,另一个线程也通过这个判断语句,这是便会差生多个实例。所以再多线程环境下不可使用这种方式。
    3. 结论:再实际开发中,不要使用这种方式。
  • 懒汉式(线程安全,同步方法)

    • 代码

      class Singleton{
        private static Singleton singlenton;
        private Singleton(){}
        //加入了同步代码,解决线程不安全问题
        public static synchronized Singlenton getInstance(){
            if(singleton==null){
                singleton=new Singleton();
            }
            return singleton;
        }
      }
    • 优缺点说明

      1. 解决了线程不安全的问题
      2. 效率太低了,每个线程在想获得类的实例时候,执行getInstance()方法都要进行同步。而其实这个方式执行一次实例化代码就够了,后面的想获得该类实例直接return就行了。方法进行同步效率太低
      3. 结论;在实际开发中,不推荐使用这种方式。
    • 懒汉式(线程安全,同步代码块)

    • 代码

      class Singleton{
        private static Singleton singleton;
        private Singleton(){}
        public static Singleton getInstance(){
            if(singleton==null){
                //同代码块 
                synchronized (Singleton.class){
                    singleton=new Singleton();
                }
                return singleton;
            }
        }
      }
    • 优缺点说明

      1. 这种方式,本意是相对四种方法的改进,因为前面同步方法效率太低,改为同步生产实例的代码块。
      2. <font color="red">但是这种同步并不能起到线程同步的作用</font>。跟第三种实现方式遇到的情形一致,加入一个线程进入了if(singleton==null)判断语句块,还未来得及往下执行,另外一个线程也通过了这个判断语句,这时便会产生多个实例。
      3. 结论:在实际开发中,不能使用这种方式。
    • 双重检查

    • 代码演示

      class Singleton{
        //volatile把它认为是一个轻量级的synchronized
        private static volatile  Singleton singleton;
        private Singleton(){}
        public static Singleton getInstance(){
          if(singleton==null){
                //保证只有一个线程在这里执行,当下一个线程进来的时候,
                //上一个线程已经创建完了singleton已经不等于null了,就不会创建了
                //提供一个静态的共有方法,加入双重检查代码,解决线程安全问题,同时解决懒加载问题
                //同时保证了效率,推荐使用    
                synchronized(Singleton.class){
                    if(singleton==null){
                        singleton=new Singleton();
                    }
                }
            }
            return singleton;
        }
      }
    • 优缺点说明

      1. Double-“Check概念是多线程开发中常使用的,如果代码中所示,我们进行了两次if(singleton==null)检查,这样就可以保证线程安全了。
      2. 这样,实例化代码只用执行一次,后面再次访问时,判断if(singleton==null),直接return实例化对象,也避免的反复进行方法同步。
      3. 线程安全;延迟加载;效率较高
      4. 结论;在实际开发中,推荐使用这种单例设计模式。
    • 静态内部类

    • 代码演示

      //当外部类装载的时候静态内部类不会被装载的
      //当我们调用静态方法时静态内部类的时候只会装载一次,而且装载的时候线程是安全的。
      public class SingletonTest07 {
        public static void main(String[] args) {
            Singleton instance = Singleton.getInstance();
            Singleton instance1 = Singleton.getInstance();
            System.out.println(instance == instance1);//true
            System.out.println("instance.hashCode=" + instance.hashCode());//instance1.hashCode=1163157884
            System.out.println("instance1.hashCode=" + instance1.hashCode());//instance1.hashCode=1163157884
        }
      }
      //静态内部类完成,推荐使用
      class Singleton {
        //构造器私有化
        private Singleton() { }
        //写静态内部类,该类有一个静态属性
        private static class SingletonInstance {
            private static final Singleton INSTANCE = new Singleton();
        }
        //提供一个静态的共有方法,直接返回SingletonInstance.INSTANCE
        public static Singleton getInstance() {
            return SingletonInstance.INSTANCE;
        }
      }
    • 优缺点说明

      1. 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
      2. 静态内部类方式在Singleton类被装载时并不会立即实例化,而是在需要实例化时调用getInstance方法,才会装载Singleton Instance类,从而完成Singleton的实例化。
      3. 类的静态属性只会加载类的时候初始化,所以在这里,jvm帮助我们保证了线程的安全性,再类进行初始化时,别的线程是无法进入的。
      4. 优点;避免了线程不安全,利用静态内部类特点实现延迟加载,效率高
      5. 结论;推荐使用。
    • 枚举

    • 代码实例

      public class SingletonTest8 {
        public static void main(String[] args) {
            Singleton instance = Singleton.INSTANCE;
            Singleton instance2 = Singleton.INSTANCE;
            System.out.println(instance == instance2);//true
            System.out.println(instance.hashCode());//1163157884
            System.out.println(instance2.hashCode());//1163157884
            instance.sayOK();
        }
      }
      //使用枚举可以实现单例,推荐使用
      enum Singleton {
        INSTANCE;
        public void sayOK() {
            System.out.println("ok~");}
      }
    • 优缺点说明
      1. 这借助jdk1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象。
      2. 这种方式式Effective java作者 josh bloch 提倡的方式
      3. 结论;推荐使用

单例模式在jdk应用的源码分析

  • 单例模式在jdk应用的源码分析

    1. 我们jdk中 java.lang.Runtime 就是经典的单例模式
    2. 代码分析+Ddbug源码+代码说明
    //单例设计模式的懒汉式
    public class Runtime {
      private static Runtime currentRuntime = new Runtime();
          public static Runtime getRuntime() {
          return currentRuntime;
      }
      private Runtime() {}

单例模式注意事项和细节说明

  1. 单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能
  2. 当想实例一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new
  3. 单例模式使用的场景:需要频繁的进行创建和销毁的对象,创建对象时耗时过多或耗费资源过多(即:重量级对象),但又经常用到的对象,工具类对象,频繁访问数据库或文件的对象(比如数据源,session工程等)