单例模式之懒汉式

文章目录

• 单例模式（懒汉式）
• • 代码
  • • 懒汉式（线程不安全）
    • 懒汉式（线程安全，加锁）
    • 双重检查锁（线程安全，推荐）

单例模式（懒汉式）

懒汉式是符合懒加载的模式，但是会存在线程并发的问题发生，所以还需要一种解决线程并发的机制，比如：加锁等

单例模式懒汉式主要的构成是如下

• 单例类
• 私有化构造函数（防止实例化）
• 私有化变量
• 公共静态获得实例的方法(在调用这个方法的时候才进行实例化)
• 解决线程并发的机制

代码

懒汉式（线程不安全）

package singleton.type3;

/**
 *
 *
 * @author: Hui
 **/
public class SingletonTest3 {
    
    public static void main(String[] args) {
          Singleton singleton =   Singleton.getInstance();
          Singleton singleton1 =   Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
    }
}

class Singleton{
    
    //1.构造器私有化
    private Singleton(){}
    
    //2.静态实例私有化
    private static Singleton singleton;

    //3.提供实例的静态方法
    public static Singleton getInstance(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

以上方法虽然实现了懒加载，但是线程不安全，在实际开发情况下不能使用。

因为以上代码会出现线程不安全的情况，那么我们如何保证线程安全呢？最简单的就是加锁，在提供实例的静态方法中加锁，就可以保证线程安全了。

懒汉式（线程安全，加锁）

package singleton.type4;
/**
 * @author: Hui
 **/
public class SingletonTest4 {

    public static void main(String[] args) {
        System.out.println("线程安全，加锁");
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
    }
}

class Singleton {

    //1.构造器私有化
    private Singleton() {
    }

    //2.静态实例私有化
    private static Singleton singleton;

    //3.提供实例的静态方法
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

虽然解决了线程安全问题，但是性能太差了，每一次调用实例都需要进入同步方法，其实我们创建实例的时候保持同步就可以了。这个方法因为性能比较差，开发过程中不建议使用。

那上述锁的是一个方法，我们可不可以将锁的颗度降低，锁住一个代码块呢？

代码如下

  //3.提供实例的静态方法
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            
            synchronized(Singleton){
                 singleton = new Singleton();
            }
        }
        return singleton;
    }

像以上方法是不是就实现了提高性能呢？是的，但是也出现了线程不安全的问题，比如有多个线程进入 if (singleton == null) 那么是不是会有多个线程进行创建对象。所以为了减少颗粒度又要保证线程安全，我们可以使用双层检查锁来完成！！！

  //3.提供实例的静态方法
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            
            synchronized(Singleton.class){
     			if (singleton == null){
                    singleton = new Singleton();
                } 
            }
        }
        return singleton;
    }

我们只需要在加锁的代码块中再进行一次空判断，就可以很好的解决并发问题了，当一个线程进入的时候，先判断是否为空，为空才创建对象，不为空直接返回。

双重检查锁很好的解决线程不安全问题，并且达到性能的提升。

在实际开发中推荐使用

双重检查锁（线程安全，推荐）

package singleton.type5;

/**
 * @author: Hui
 **/
public class SingletonTest5 {
    public static void main(String[] args) {
        System.out.println("双重检查锁，推荐使用");
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
    }
}

class Singleton {

    //1.私有化构造器
    private Singleton() {
    }

    //2.声明静态变量，volatile 保证内存的可见性
    private static volatile Singleton instance;

    public static Singleton getInstance() {

        if (instance == null) {
            synchronized (Singleton.class) {
                //双重检查锁
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }

        return instance;
    }

}

注意变量一定要使用 volatile 修饰，保证变量内存修改时的可见性。