Java面试 - 什么是单例设计模式，为什么要使用单例设计模式，如何实现单例设计模式(饿汉式和懒汉式)？

什么是单例设计模式？

单例设计模式就是一种控制实例化对象个数的设计模式。

为什么要使用单例设计模式？

使用单例设计模式可以节省内存空间，提高性能。因为很多情况下，有些类是不需要重复产生对象的。

如果重复产生对象的话，会导致大量的内存空间被占用，性能降低。

例如：在程序启动中，加载已保存的数据信息。这些数据信息是由一个单例对象统一读取，其他程序只需要通过这个单例对象获取加载的数据信息即可。

单例设计模式分为饿汉式和懒汉式。饿汉式是在系统加载类的时候就会自动提供类的实例化对象如Computer computer。

懒汉式是在第一次使用的时候进行实例化对象处理。

饿汉式单例设计模式实现源码：

class Computer{

  //1、私有化 Computer 构造函数
  private Computer(){
    System.out.println("私有化 Computer 构造函数");
  }
  public void printInfo(){
    System.out.println("Computer 类使用的就是单例设计模式");
  }

  // 2、调用私有化 Computer 构造函数并将computer属性设置为static
  private static Computer computer = new Computer();

  // 3、提供getCompter()方法，便于调用
  public static Computer getCompter(){
    return computer;
  }
}

public class Demo {

  public static void main(String[] args) {
    // 产生单例对象
    Computer computer = Computer.getCompter();

    // 调用printInfo()方法
    computer.printInfo();
  }
}

运行结果：

私有化 Computer 构造函数
Computer 类使用的就是单例设计模式

饿汉式单例设计模式的实现过程分析：

1、所有新的实例化对象的产生都会调用构造方法，如果无法正常调用构造方法的话，也就不能产生新的实例化对象。

如果想控制实例化对象个数的话，那么就应该控制构造函数。因此首先将该类的构造方法定义为私有方法。

private Computer(){
    System.out.println("私有化Computer 构造函数");
  }

2、类的构造方法私有化后，在类的外部就不能产生实例化对象。但是Private 修饰的构造方法可以在类的内部访问。

如果要访问Private 修饰的构造方法，可以在类的内部调用构造函数。

private Computer computer = new Computer();

3、computer 作为普通属性，只有在实例化对象产生之后才能被调用。由于类的外部无法产生实例化对象，如果想获取

computer 属性，可以将computer 属性设置为static。

private static Computer computer = new Computer();

4、对于private 属性 computer来说，如果想在类的外部获取该属性，则需要通过getComputer()方法获取。

public static Computer getCompter(){
    return computer;
  }

由于饿汉式在类加载的时候就完成了对象实例化，如果程序始终没有用到这个实例化对象，那么就会造成内存空间的浪费。

为了不浪费内存空间，懒汉式是在第一次使用的时候进行实例化对象处理。

懒汉式单例设计模式实现源码：

class Computer{

  //1、私有化 Computer 构造函数
  private Computer(){
    System.out.println("私有化 Computer 构造函数");
  }
  public void printInfo(){
    System.out.println("Computer 类使用的就是单例设计模式");
  }

  // 2、调用私有化 Computer 构造函数并将computer属性设置为static
  private static Computer computer;

  // 3、提供getCompter()方法，便于调用
  public static Computer getCompter(){

    // 懒汉式，按需创建 即在第一次使用的时候进行实例化对象
    if(computer == null){
      computer = new Computer();
    }
    return computer;
  }
}

public class Demo {
  public static void main(String[] args) {
    // 产生单例对象
    Computer computer = Computer.getCompter();

    // 调用printInfo()方法
    computer.printInfo();
  }
}

运行结果：

私有化 Computer 构造函数
Computer 类使用的就是单例设计模式

懒汉式单例设计模式的实现源码分析：

为了避免实例化的对象始终没有被使用，造成内存空间的浪费，所以增加了对实例化对象的判断，

即如果实例化对象为null 则创建实例化对象。

// 懒汉式，按需创建 即只有在第一次使用的时候才进行实例化对象
    if(computer == null){
      computer = new Computer();
    }

但是如果在多线程下，会出现这样的情况即一个线程进入了if 语句， 另一个线程也通过了if语句。

这样就产生了多个实例化对象。 为了避免这样的问题，可以采用双重加锁机制。

双重加锁机制优化懒汉式源码：

class Computer{
  //1、私有化 Computer 构造函数
  private Computer(){
    System.out.println("私有化 Computer 构造函数");
  }

  public void printInfo(){
    System.out.println("Computer 类使用的就是单例设计模式");
  }

  // 2、调用私有化 Computer 构造函数并将computer属性设置为static
  private volatile static Computer computer;

  // 3、提供getCompter()方法，便于调用
  public static Computer getCompter(){
    // 第一次检查
    if(computer == null){
      // 加锁
      synchronized (Computer.class){
        // 第二次检查
        if (computer == null){
          computer = new Computer();
        }
      }
    }
    return computer;
  }
}

public class Demo {
  public static void main(String[] args) {
    // 产生单例对象
    Computer computer = Computer.getCompter();

    // 调用printInfo()方法
    computer.printInfo();
  }
}

运行结果：

私有化 Computer 构造函数
Computer 类使用的就是单例设计模式

双重加锁机制优化懒汉式源码分析：

 // 2、调用私有化 Computer 构造函数并将computer属性设置为static
  private volatile static Computer computer;

  // 3、提供getCompter()方法，便于调用
  public static Computer getCompter(){
    // 第一次检查
    if(computer == null){
      // 加锁
      synchronized (Computer.class){
        // 第二次检查
        if (computer == null){
          computer = new Computer();
        }
      }
    }
    return computer;
  }

1、volatile可以保证多线程下的可见性即保证了子线程的会跟主线程的一致。

2、当thread2，进入第一个if(computer == null) 语句，子线程的computer为空的，thread2释放资源给thread3。

3、当thread3，进入第一个if(computer == null) 语句，子线程的computer为空的，thread3释放资源给thread2。

4、当thread2，进入第二个if(computer == null) 语句，执行computer = new Computer()，实例化对象computer，volatile修饰的变量computer，会马上同步到主线程的变量computer，执行完成后thread2释放资源给thread3。

5、当thread3，进入第二个if (computer == null) 语句，此时子线程的computer不为空，所以thread3不再会重复实例化computer。