JavaEE(系列8) -- 多线程案例(单例模式)

目录

1. 设计模式

2. 单例模式 -- 饿汉模式

3. 单例模式 -- 懒汉模式 

4. 单例模式(懒汉模式-多线程) 

---

1. 设计模式

什么是设计模式?
        设计模式好比象棋中的 "棋谱". 红方当头炮, 黑方马来跳. 针对红方的一些走法, 黑方应招的时候有一些固定的套路. 按照套路来走局势就不会吃亏.

        软件开发中也有很多常见的 "问题场景". 针对这些问题场景, 大佬们总结出了一些固定的套路. 按照这个套路来实现代码, 也不会吃亏.

         单例模式能保证某个类在程序中只存在唯一一份实例, 而不会创建出多个实例.在特定场景下只被允许创建一个对象,比如在中国实行的是一夫一妻制.

2. 单例模式 -- 饿汉模式

class MySingleton {

    //static 该属性属于类的属性
    //JVM 每个类对象只有唯一一份,类对象里的这个成员自然也就是唯一一份.
    //instance是唯一实例
    private static MySingleton instance = new MySingleton();

    private MySingleton(){
        //禁止外部创建新的实例
        //将构造方法设置为private
    };

    public static MySingleton getInstance() {
        return instance;
    }

    public static void setInstance(MySingleton instance) {
        MySingleton.instance = instance;
    }
}
public class Singleton1 {
    public static void main(String[] args) {
        //1.此时s1 和 s2 是同一个对象
        MySingleton s1 = MySingleton.getInstance();
        MySingleton s2 = MySingleton.getInstance();
        System.out.println(s1 == s2);

        //2.我们要禁止这个new操作,把该类的构造方法用private修饰
        //Singleton.MySingleton s3 = new Singleton.MySingleton();
    }
}

上述代码就是单例模式中的饿汉模式

1.加载类的同时,创建实例对象.

2.同时将构造方法变为私有

理解:我吃完饭,我就把碗洗了

3. 单例模式 -- 懒汉模式

class MySingletonLazy{
    private static MySingletonLazy instance = null;
    public static MySingletonLazy getInstance(){
        if (instance == null){
            instance = new MySingletonLazy();
        }
        return instance;
    }
    private MySingletonLazy(){

    }
}

上述代码就是单例模式中的懒汉模式

1.加载类的时候,没有创建实例对象.而是写成一个静态方法,当需要创建对象的时候调用静态方法,创建对象.

2.同时将构造方法变为私有

理解:吃完饭,没有把碗洗了,而是我什么时候用,什么时候洗碗

4. 单例模式(懒汉模式-多线程) 

思考:

上述两种模式,加入多线程是否是线程安全的?

答案: 饿汉模式安全,懒汉模式不安全

在多线程中，懒汉模式可能无法保证创建对象的唯一性。

如何解决由于懒汉模式(多线程)引起的线程的不安全呢?

答案: 加锁  保证判定操作和new操作是原子性的。

class MySingletonLazy2{
    volatile private static MySingletonLazy2 instance = null;

    public static MySingletonLazy2 getInstance(){
           synchronized (MySingletonLazy.class){
                //保证原子性
                if (instance == null){
                    instance = new MySingletonLazy2();
                }
            }
        return instance;
    }
}

上述,我们对判断是创建对象这一块进行了加锁,从而保证了创建对象的原子性.

但是,如果这样,由于我们每次都要判断是否有了对象实例,就要不停地加锁解锁,这就是一个开销比较高的事情了.

如何解决频繁的加锁解锁这个过程呢?

答案:

加锁 / 解锁是一件开销比较高的事情. 而懒汉模式的线程不安全只是发生在首次创建实例的时候.
因此后续使用的时候, 不必再进行加锁了,那么我们就在加锁之前判断是否已经有实例.使用双重if进行判断 .代码如下:

class MySingletonLazy2{
    volatile private static MySingletonLazy2 instance = null;

    public static MySingletonLazy2 getInstance(){
        //外层的if,判定是否要加锁,如果对象已经有了,就没必要进行加锁,此时是线程安全的了,
        //加锁 / 解锁是一件开销比较高的事情. 而懒汉模式的线程不安全只是发生在首次创建实例的时候.
        //因此后续使用的时候, 不必再进行加锁了.
        if (instance == null){
            //解释:如果线程2执行到这里,发现对象还没创建,就会进行下一步,此时如果线程1正在创建对象,那么2就会进入堵塞状态,
            // 等待线程1创建玩对象,锁解除,那么线程2此时判断对象已经建立,此时就不会创建新的对象,此时就保证了线程之间的安全.
            synchronized (MySingletonLazy.class){
                //保证原子性
                if (instance == null){
                    instance = new MySingletonLazy2();
                }
            }
        }
        return instance;
    }
}

 //解释:如果线程2执行到第一个if里面,发现对象还没创建,就会进行下一步,此时如果线程1正在创建对象,那么2就会进入堵塞状态,
 // 等待线程1创建玩对象,锁解除,那么线程2此时判断对象已经建立,此时就不会创建新的对象,此时就保证了线程之间的安全.

这就是上述加了双重if的好处.

细心的读者还会发现,上述代码instance的修饰加上了volatile关键字,这一步为了避免“内存可见性”导致读取的instance出现偏差，于是补充上volatile,这也是优化的关键一步.