解决多线程环境下单例模式同时访问生成多个实例

如何满足单例：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;
    }
}

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