java饿汉式有啥作用,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。