反射——懒汉单例模式（解决多线程下也能保持单例模式）

懒汉单例模式

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;

class Singleton {
    private static Singleton singleton;

    private Singleton() {  //构造方法私有化
        System.out.println("【Singleton类构造】实例化Singleton类对象");
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        	Singleton singleton = Singleton.getInstance();
        }
    }
}

运行结果如下：

单例模式的特点是 jvm运行的时候从始至终只会创建一个对象实例在jvm中运行。
所以但上述代码 是有问题的 ，我们可以加入多线程试一下

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;

class Singleton {
    private static Singleton singleton;

    private Singleton() {  //构造方法私有化
        System.out.println("【Singleton类构造】实例化Singleton类对象");
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        for (int x = 0; x < 10; x++) {
            new Thread(() -> {
                Singleton singleton = Singleton.getInstance();
            }).start();
        }
    }
}

运行结果如下：

在jvm运行的过程中创建了多个实例化对象所以如下：
（再次强调）单例设计的本质在于，一个JVM进程只允许有一个实例化对象，但是一旦使用了多线程，并且结合了懒汉式设计的时候，程序代码中出现了对象的多次实例化，如果要想解决当前的问题，唯一可以想到的就是同步处理。

追加同步：

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;

class Singleton {
    private static Singleton singleton;

    private Singleton() {  //构造方法私有化
        System.out.println("【Singleton类构造】实例化Singleton类对象");
    }

    public synchronized static Singleton getInstance() { // 加入同步锁
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        for (int x = 0; x < 10; x++) {
            new Thread(() -> {
                Singleton singleton = Singleton.getInstance();
            }).start();
        }
    }
}

运行结果：

此时利用了同步解决了单例实例化的问题，但是随之而来所带来一个新的情况：如果说现在要是有十万个线程获取我们Singleton 类的实例化对象，那么最终就会造成十万个线程要依次同步等待后获取，直接将产生严重的性能问题。
那么现在问题就是：如果要保证读取的高性能就不能加synchronized,要保证更新的正确性就要加上synchronized于是这时候到底要保谁的问题 。

其实 我们可以结合反射的功能解决这一问题：

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;

class Singleton {
    private static Singleton singleton;

    private Singleton() {  //构造方法私有化
        System.out.println("【Singleton类构造】实例化Singleton类对象");
    }

    public  static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class){  //对象锁 如果指定的对象被占用，则就处于等待状态
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        for (int x = 0; x < 10; x++) {
            new Thread(() -> {
                Singleton singleton = Singleton.getInstance();
            }).start();
        }
    }
}

这样的话 我们就可以解决在多线程下的问题（懒汉式单例结合多线程控制）