多线程案例1:单例模式

多线程系列文章目录

---

💥 💥 💥如果你觉得我的文章有帮助到你，还请【关注➕点赞➕收藏】，得到你们支持就是我最大的动力!!!
💥 💥 💥

⚡版权声明：本文由【马上回来了】原创、在CSDN首发、需要转载请联系博主。
版权声明：本文为CSDN博主「马上回来了」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

🚀🚀🚀 新的知识开始喽🚀🚀🚀

---

1.什么是单例模式

就是在实际业务逻辑中,只能创建一个实例对象.
那么如何才能才能只创建一个实例对象呢?一个实例对象也就是说只有一份,static静态属性刚好能满足要求.
static虽然是叫"静态",但static的实际属性和名字关联不大,static属于是类的属性,被它修饰的方法或成员都属于类属性,在加载.class文件时就会加载出来,static属性不归任何一个实例对象所持有,static属性的成员/方法只有一份,是所有对象共有的.
因此我们就可以使用static实现单例模式.

2.饿汉模式

1.只能实例化一个对象:对象在自己类内部创建,static修饰对象引用,private修饰构造方法
2.只能通过getInstance方法获取到这个对象的引用:getInstance必须是静态的方法,通过类名来访问这个方法.

class SingleTon{
    //static 类属性,只能有一份;private修饰,类外无法直接拿到这个引用
      private static SingleTon singleTon = new SingleTon();
      //只能通过getInstance方法拿到这个引用;这个方法必须是static属性,因为在饿汉模式下只能通过类名来调这个方法
      public static SingleTon getInstance(){
          return singleTon;
      }
//构造方法用private的修饰,类外无法直接调用到这个类的构造方法,也就无法再次实例化多个对象
    private SingleTon() {
    }
}
public class demo1 {
    public static void main(String[] args) {
       SingleTon.getInstance(); 
    }
}

由于对象的创建在类加载时就已经完成,因此创建的很快,所以称为饿汉模式.

3.懒汉模式

懒汉模式,顾名思义比较懒,实例对象的创建在类加载时并没有创建,而是在类加载完毕之后,如果调用了静态方法 getSingleTonLazy()才会创建实例对象.

懒汉模式比饿汉模式的效率更高,正真要创建单个实例对象时,调用 getSingleTonLazy()方法就能创建实例对象,这样在类加载时和其他耗时的操作分开了,一般在程序刚启动时,类在加的资源比较多,因此资源紧张.
而且如果不需要创建实例对象就不用调用getSingleTonLazy(),也就节省下了一下资源空间.

class SingleTonLazy{
    //在类加载时并没有创建实例对象 private修饰,类外无法直接拿到
    private static SingleTonLazy singleTonLazy  = null;
    //构造方法也是用private修饰,无法在创建出实例对象
    private SingleTonLazy() {
    }

    //只有在调用getSingleTonLazy时才会创建对象 static方法,通过类名来访问
    public static SingleTonLazy getSingleTonLazy(){
        if (singleTonLazy == null){
            singleTonLazy = new SingleTonLazy();
        }
        return singleTonLazy;

    }

}
public class demo2 {
    public static void main(String[] args) {
        SingleTonLazy.getSingleTonLazy();
    }
}

4.单例模式的线程安全问题

饿汉模式线程安全
饿汉模式里getInstance方法只涉及到读操作,因此线程安全.
懒汉模式线程不安全
1.懒汉模式里的getSingleTonLazy()方法不仅涉及到读操作,还涉及到写操作,因此线程不安全:

2.因此就得给getSingleTonLazy()里的整个读和写的过程加锁:

3.这样加锁效率并不高,这样加锁每次线程调用这个方法时都会加锁,浪费了多余的开销.
而单例模式里我们只想创建一个实例对象,因此也就只要在第一次调用这个方法时保证线程安全加锁,之后在调用这个方法时,只用判断一下,这个方法是不是已经被调用过了,如果已经被调用过了,就说明已经创建好实例对象了,就不用在加锁继续调用这个方法了:

4.这个代码还有一个问题,出现在锁的内部new对象这个过程里:

使用关键字volatile就可以解决指令重排序带来的问题:

因此线程安全的懒汉模式的完整代码:

class SingleTonLazy{
    //在类加载时并没有创建实例对象 private修饰,类外无法直接拿到 volatile避免指令重排序和内存可见性带来问题
    private static volatile SingleTonLazy singleTonLazy  = null;
    //构造方法也是用private修饰,无法在创建出实例对象
    private SingleTonLazy() {
    }

    //只有在调用getSingleTonLazy时才会创建对象 static方法,通过类名来访问
    public static SingleTonLazy getSingleTonLazy(){
        if(singleTonLazy == null){
            synchronized (SingleTonLazy.class){//注意这里锁的对象不能是this
                if (singleTonLazy == null){
                    singleTonLazy = new SingleTonLazy();
                }
                return singleTonLazy;
            }
        }
        return singleTonLazy;


    }

}
public class demo2 {
    public static void main(String[] args) {
        SingleTonLazy.getSingleTonLazy();
    }
}

---

---

🌏🌏🌏今天的你看懂这里又学到了很多东西吧🌏🌏🌏

🌔 🌔 🌔下次见喽🌔 🌔 🌔