如何满足单例：1.构造方法是private、static方法、if语句判断

①、单线程

Single类

//Single类，定义一个GetInstance操作，允许客户访问它的唯一实例。GetInstance是一个静态方法，主要负责创建自己的唯一实例
public class LazySingleton {private static LazySingleton instance;private LazySingleton() {System.out.println("创建一次");}public static LazySingleton GetInstance() {//当多线程来临的时候判断是否为null，此时instance就是临界资源，会实例化多个if (instance == null) {instance = new LazySingleton();}return instance;}
}

//客户端代码

public class Main {public static void main(String[] args) {LazySingleton s1= LazySingleton.GetInstance();LazySingleton s2=  LazySingleton.GetInstance();if(s1==s2){System.out.println("两个对象是相同的实例");}}
}

运行结果：

这样的话就满足了单例的效果，保证只实例化一个类，因为LazySingleton封装它的唯一实例，这样它可以严格地控制客户怎样访问它以及何时访问它。简单地说就是对唯一实例的受控访问。客户端通过那唯一可以访问的GetInstance方法来访问那一个实例。但如果是多个线程同时调用GetInstance方法，同时运行到了GetInstance方法这儿，它们都会去判断有没有被实例化，判断都为True，那样的话就创建了两个实例，就违背了单例模式，不是一个单例。看下多线程下的单例：

②、多线程

单例类

public class LazySingleton {private static LazySingleton instance;private LazySingleton() {System.out.println("创建一次");}public static LazySingleton GetInstance() {//当多线程来临的时候判断是否为null，此时instance就是临界资源，会实例化多个if (instance == null) {instance = new LazySingleton();}return instance;}
}

main函数

public class Main {public static void main(String[] args) {Runnable r=()->{LazySingleton s1= LazySingleton.GetInstance();LazySingleton s2=  LazySingleton.GetInstance();if(s1==s2){System.out.println("两个对象是相同的实例");}};//两个线程Thread t1= new Thread(r);Thread t2= new Thread(r);t1.start();t2.start();}
}

运行结果：

我们会发现对象被创建了两次，我们通过调试发现s1和s2两个对象的地址实际上是不一样的：

当线程t1刚执行完if (instance == null)判断之后时间片到了，t2线程执行完if (instance == null)判断之后就进入方法体生成了实例，此时t1线程又获得了时间片，t1会接着上次中断的地方继续执行，t1线程便会进入方法体又生成了一个新的实例，此时t1和t2线程各生成了一个实例

如何解决这样一个问题呢？

添加锁，当线程位于临界区的时候就上锁，其他线程来临的时候只能在外排队等待。

③、多线程单例——单锁

单例类

package com.example;public class LazySingleton {private static LazySingleton instance;private LazySingleton() {System.out.println("创建一次");}public static LazySingleton GetInstance() {//当多线程来临的时候判断是否为null，此时instance就是临界资源，会实例化多个//方法：加锁-把判断的这部分逻辑上锁synchronized ("") {if (instance == null) {instance = new LazySingleton();}}return instance;}}

main函数

public class Main {public static void main(String[] args) {Runnable r=()->{LazySingleton s1= LazySingleton.GetInstance();LazySingleton s2=  LazySingleton.GetInstance();if(s1==s2){System.out.println("两个对象是相同的实例");}};//两个线程Thread t1= new Thread(r);Thread t2= new Thread(r);t1.start();t2.start();}
}

运行结果：

发现对象创建了一次。在同一时刻加了锁的那部分程序只有一个线程可以进入，我们可以让最先进入的那个线程先上一把锁，创建实例。后面在进入的线程就不会再去创建对象实例了，因为第一名来的线程已经创建了，你这个判断的结果是False，自然无法创建了。这样的话就保证了多个线程同时访问的话不会有多个实例化。解决了上面单实例带来的问题。但每次进入的线程都需要先加锁在判断，我都还不知道有没有创建过这个实例呢你就让我加锁，第一名已经实例化过了，我进去再加锁，在判断一次，如果有上百个线程同时访问呢，这样的工作重复上百次，不是很影响我这个程序的性能吗？我们就可以用到双重锁定来解决这个问题

④、多线程——双重锁（Double-Check Locking）

package com.example;public class DoubleLockSingleton {private static DoubleLockSingleton instance;private DoubleLockSingleton() {System.out.println("实例化了一次");}public static DoubleLockSingleton GetInstance() {//第一层判断：先判断实例是否存在，不存在再加锁处理if (instance == null) {synchronized ("") {//第二层判断if (instance == null) {instance = new DoubleLockSingleton();}}}return instance;}
}

通过这样两重的判断，进入的线程不用每次都加锁，只是在实例未被创建的时候在加锁处理。同时也保证多线程的安全。