最简单的设计模式不会还有人不会吧！

时间 2021-01-02

标签 java 程序员数据库编程设计模式安全 session 多线程框架 jvm 栏目 Java 繁體版

原文原文链接

前言

掌握设计模式的层次java

刚开始学编程不久，据说过什么是设计模式
由很长时间的编程经验，本身写了不少代码，其中用到了设计模式，可是本身殊不知道
学习过了设计模式，发现本身已经在使用了，而且发现了一些新的模式挺好用的
阅读了不少别人写的源码和框架，在其中看到别人设计模式，而且可以领会设计模式的精妙和带来的好处。
代码写着写着，字节都没有意识到使用了设计模式，而且熟练的写了出来。

设计模式介绍程序员

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

设计模式分为三种类型，共23种数据库

建立型模式：单例模式，抽象工厂模式，原型模式，建造者模式，工程模式。编程
结构型模式：适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式设计模式
行为型模式：模块方法模式，命令模式，访问者模式，迭代模式，观察者模式，中介者模式，备忘录模式，解释器模式(Interpreter模式)，状态模式，策略模式，职责链模式(责任链模式)安全

注意:不一样的书籍上对分类和名称略有差异。session

单例模式

单例模式介绍多线程

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

好比Hibernate的SessionFactory，他充当数据存储源的代理，并负责建立Session对象。SessionFactory并非轻量级的，通常状况下，一个项目一般只须要一个SessionFactoury就够，这是就会用到单例模式。jvm
单例设计模式有八种写法
1. 饿汉式(静态常量)
2. 饿汉式(静态代码块)
3. 懒汉式(线程不安全)
4. 懒汉式(线程安全，同步方法)
5. 懒汉式(线程安全，同步代码块)
6. 双重检查
7. 静态内部类
8. 枚举

饿汉式(静态常量)

步骤以下:

构造器私有化(防止 new)
类的内部建立对象
向外暴露一个静态的公共方法。gentInstance

代码实现

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;
  }
}

优势说明

起到Lazy Loading的效果，可是只能再单线程下使用。
若是再多线程下，一个线程进入if(singlenton == null) 判断语句块，还将来得及往下执行，另外一个线程也经过这个判断语句，这是便会差生多个实例。因此再多线程环境下不可以使用这种方式。
结论：再实际开发中，不要使用这种方式。

懒汉式(线程安全，同步方法)

代码

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中 java.lang.Runtime 就是经典的单例模式
代码分析+Ddbug源码+代码说明

//单例设计模式的懒汉式
public class Runtime {
  private static Runtime currentRuntime = new Runtime();
      public static Runtime getRuntime() {
      return currentRuntime;
  }
  private Runtime() {}

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

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