目录

                               🚀1.什么是单例模式

                           🚀 2.饿汉模式

    🚀3.懒汉模式--多线程(不安全版本)

                   🚀4.懒汉模式--多线程(安全版本)

              🚀5 总结

1.什么是单例模式

单例模式其实是一种设计模式,在平常工作中很常用,是一种固定的模板,就像下棋的棋谱一样,这个很重要,需要我们重点掌握

单例模式分为饿汉模式和懒汉模式,饿汉模式是急迫型的,而懒汉模式是从容型的

举个很简单的例子,从硬盘读取内容到显示器上,有两种方式,一种是要等一会,把所有的数据全都读到显示器上,还有一种是立即显示,一点一点读,前者是饿汉模式,后者就是懒汉模式,两者相比,当然是懒汉模式更高效了

2.饿汉模式

下面我们就来实现一下单例模式的第一个:饿汉模式

class Singleton{
    //创建唯一一个实例
    private static Singleton  instance=new Singleton();
    //获取唯一实例
    public static Singleton getInstance(){
        return instance;
    }
        //构造方法私有化,保证不能再new实例
    private Singleton(){
    }
}
public class ThreadingDemo1 {
    public static void main(String[] args) {
            Singleton s1=Singleton.getInstance();
            Singleton s2=Singleton.getInstance();
    }
}

这样写s1和s2获取到的都是唯一的实例

当再次想new的时候,就会报错

所谓单例模式,就是保证只能有一个实例

3.懒汉模式(不安全版本)

懒汉模式就是能不new就不new,需要我new我再new

下面来实现一下懒汉模式

class SingletonLazy{
    private static SingletonLazy instance=null;
    public static SingletonLazy getInstance(){
        if(instance==null){
            instance=new SingletonLazy();
        }
        return instance;
    }
    private  SingletonLazy(){
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
            SingletonLazy s1=SingletonLazy.getInstance();
            SingletonLazy s2=SingletonLazy.getInstance();
        System.out.println(s1==s2);
    }
}

懒汉就是我先不创建对象,需要的时候我再干活

下面我们来分析一下这两个代码

饿汉模式中,没有涉及到修改操作,就是一个简单的返回 ,一个简答的读操作.所以是线程安全的

懒汉模式中,如果是单个线程调用,那一定就是线程安全的,但是在多线程中,如果多个线程调用new操作,那么就不安全了,类似于count++操作,不是原子的了,下面来画个图

这个情况就会new多个对象,那么 就会产生线程不安全的问题

其实也就是因为操作不是原子引起的,if 判断和new操作不是原子的,所以我们采用加锁的方式

如下面的代码

public static SingletonLazy getInstance() {
    synchronized (SingletonLazy.class) {
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }
}

其实只有在第一次new对象的时候会产生这样的问题,所以如果每一次都加锁就很耗费资源,降低效率,所以我们再加锁前,判断一下要不要加锁,如果对象还没有创建,那就加锁,如果已经有了,就不用再加锁了,那么就使用双重if判定

注意!!!

这里的两个if条件一模一样,但是意义天差地别,第一个if是判断要不要加锁,第二个if是为了判断要不要new一个对象,创建一个实例

如下代码

public static SingletonLazy getInstance() {
    if (instance == null) {
        synchronized (SingletonLazy.class) {
            if (instance == null) {
                instance = new SingletonLazy();
            }
        }
    }
        return instance;
}

然后针对new操作,可能会产生指令重排序的问题,之前我们就讨论过这个问题,这里就不再赘述,那么我们为了防止这个问题的产上,使用volatile关键字

4.懒汉模式(安全版本)

最终代码

class SingletonLazy {
      volatile private static SingletonLazy instance = null;
    public static SingletonLazy getInstance() {
        if (instance == null) {
            synchronized (SingletonLazy.class) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
            return instance;
    }
    private  SingletonLazy(){
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
            SingletonLazy s1=SingletonLazy.getInstance();
            SingletonLazy s2=SingletonLazy.getInstance();
        System.out.println(s1==s2);
    }
}

         5.总结:

                                              保证懒汉模式线程安全办法:

           1.加锁,保证if和new是原子的

          2.双重if判定,防止不必要的加锁

   3.加volatile关键字,禁止指令重排序,保证后面的线程拿到的是完整的对象

     饿汉模式:是天然线程安全的,涉及到读操作

    懒汉模式:不安全,需要操作把它边安全

以上就是这期要分享的内容,我们下期再见了,886!!!