什么是单例设计模式？
单例设计模式就是一种控制实例化对象个数的设计模式。
为什么要使用单例设计模式？
使用单例设计模式可以节省内存空间，提高性能。因为很多情况下，有些类是不需要重复产生对象的。
如果重复产生对象的话，会导致大量的内存空间被占用，性能降低。
例如：在程序启动中，加载已保存的数据信息。这些数据信息是由一个单例对象统一读取，其他程序只需要通过这个单例对象获取加载的数据信息即可。
单例设计模式分为饿汉式和懒汉式。饿汉式是在系统加载类的时候就会自动提供类的实例化对象如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。