设计模式学习---Java单例模式-CSDN博客

本文链接：https://blog.csdn.net/weixin_43420351/article/details/121002368

单例（Singleton）设计模式

主要是对饿汉式代码的小优化

单例设计模式保证一个类只有一个实例，并提供一个访问该实例的全局访问点。
优点是只生成一个实例，所以系统的开销小，可以设计全局访问点，优化共享资源的访问
单例设计模式中的饿汉式和懒汉式
饿汉式：直接创建对象，不存在线程同步的问题

懒汉式：延迟创建对象，线程不安全

饿汉式代码：

public class Singleton {
	
	// 2.声明本类类型的引用指向本类类型的对象，使用private static关键字共同修饰
	private static Singleton sinleton = new Singleton();  

	
	// 1.私有化构造方法，使用private关键字修饰
	private Singleton() {}

	// 3.提供公有的get方法负责将对象返回出去，使用public static关键字共同修饰
	public static Singleton getInstance() {
		return sinleton;
	}
}

懒汉式代码：

public class Singleton {
	
	// 2.声明本类类型的引用指向本类类型的对象，使用private static关键字共同修饰
	private static Singleton sinleton = null;  

	
	// 1.私有化构造方法，使用private关键字修饰
	private Singleton() {}

	// 3.提供公有的get方法负责将对象返回出去，使用public static关键字共同修饰
	public static Singleton getInstance() {
		if(null == sinleton) {
			sinleton = new Singleton();
		}
		return sinleton;
	}
}

上述代码，假设有两个线程 A B，同时调用 getInstance()方法，线程A调用时，"null == sinleton "成立，进入方法体new对象，在new对象的过程中，因为new对象需要时间，所以这时候线程B挤了进来，同样的"null == sinleton"成立，也去new了对象，这样在return的时候，就返回了两个对象，这不符合单例设计模式一个类只有一个实例的概念。所以我们说懒汉式的单例设计模式线程不安全。
当然解决该线程不安全的问题也很简单，只需要在修饰getInstance()方法的时候加一个synchronized关键字修饰（同步锁），或者可以使用如下代码中的，使用synchronized（Singleton.class）的方法，代码如下。

public class Singleton {

    // 2.声明本类类型的引用直线本类类型的对象并使用private static关键字修饰
    private static Singleton singleton = null;
    // 1.私有化构造方法，使用private关键字修饰
    private Singleton() {
    }
    // 3.提供公有的get方法负责将上述对象返回回去，使用public static关键字
   /*
   public static synchronized Singleton getInstance(){
        if(null == singleton){
            singleton = new Singleton();
        }
        return  singleton;
    }
   */
    public static Singleton getInstance(){
   			// 这样写等价于上面的直接用synchronized关键字修饰的方法,
            // "Singleton.class"用到了java的反射机制，实际上就是这个类的class对象（也就是这个类的运行时类信息），
            // 类加载到内存中的运行时类信息只有一个， 所以在这里可以实现线程同步的效果
        synchronized (Singleton.class){
            if(null == singleton){
                singleton = new Singleton();
            }
            return  singleton;
        }
}

经过以上代码，饿汉式已经解决了线程不安全的问题，但是我们在这里发现，同步锁其实锁一次就够了，因为当第一个线程调用后，singleton已经部位null，所以锁与不锁其实没什么关系了，那么在这里继续优化代码。

public class Singleton {
    // 2.声明本类类型的引用直线本类类型的对象并使用private static关键字修饰
    private static Singleton singleton = null;
    // 1.私有化构造方法，使用private关键字修饰
    private Singleton() {
    }
    // 3.提供公有的get方法负责将上述对象返回回去，使用public static关键字
    public static/*synchronized*/Singleton getInstance(){
        // 代码优化：因为只需要第一次调用的时候需要加锁，后续调用singleton不为null了  也就不需要加锁了
        if (null == singleton) {
            synchronized (Singleton.class){
                if(null == singleton){
                    singleton = new Singleton();
                }
            }
        }
        return  singleton;
    }
}