如何满足单例：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;
}
}通过这样两重的判断，进入的线程不用每次都加锁，只是在实例未被创建的时候在加锁处理。同时也保证多线程的安全。
