Java多线程 单例模式懒汉式的三种写法

单例模式懒汉式的三种写法

懒汉式单例模式的概念: 只有需要用到实例的时候才加载, 如果用不到实例, 就不会去加载, 这样就节省了内存空间.

懒汉式(线程不安全 不可用)

如下的代码是懒汉式(线程不安全)的写法.

package com.thread.jmm;

import javax.print.attribute.standard.NumberUp;

/**
 * 类名称:Singleton1
 * 类描述:  懒汉式(线程不安全 不可用)
 *
 * @author: https://javaweixin6.blog.csdn.net/
 * 创建时间:2020/9/6 19:26
 * Version 1.0
 */
public class Singleton3 {

    private static Singleton3 INSTANCE ;

    /**
     * 单例模式的构造方法都是私有的, 防止其他对象new
     */
    private Singleton3() {
        //完成初始化等操作...
    }

    /**
     * 返回单例模式对象
     * @return
     */
    public static Singleton3 getInstance() {
        if (INSTANCE == null) {
            //懒汉式,  检查是否为空,如果是空, 再初始化.
            INSTANCE = new Singleton3();
        }
        //如果不是空, 则直接返回实例. 
        return INSTANCE;
    }
}

主要的问题出现在29行代码中 . 如果两个线程同时到达了此处, 并且此时实例也没有被初始化, 那么线程1会初始化该对象, 并且线程2 也会初始化此对象, 那么就会创建两个实例, 就不符合单例模式了.

懒汉式(线程安全 同步方法 不推荐使用)

懒汉式(线程安全 同步方法 )的写法如下 , 不推荐使用

package com.thread.jmm;

/**
 * 类名称:Singleton1
 * 类描述:  懒汉式(线程安全 同步方法 不推荐使用)
 *
 * @author: https://javaweixin6.blog.csdn.net/
 * 创建时间:2020/9/6 19:26
 * Version 1.0
 */
public class Singleton4 {

    private static Singleton4 INSTANCE ;

    /**
     * 单例模式的构造方法都是私有的, 防止其他对象new
     */
    private Singleton4() {
        //完成初始化等操作...
    }

    /**
     * 返回单例模式对象
     * @return
     */
    public synchronized static Singleton4 getInstance() {
        if (INSTANCE == null) {
            //懒汉式,  检查是否为空,如果是空, 再初始化.
            INSTANCE = new Singleton4();
        }
        //如果不是空, 则直接返回实例.
        return INSTANCE;
    }
}

和上面写法的主要区别在于在创建实例的方法上,加上了synchronized关键字 . 保证了只有一个线程去创建和获取对象 . 这样虽然保证了安全性, 但是效率太低了. 多个线程获取实例的方法无法并发的去拿.

懒汉式(线程不安全 同步代码块 不可用)

如下为 懒汉式(线程不安全 同步代码块 )的写法

package com.thread.jmm;

/**
 * 类名称:Singleton1
 * 类描述:  懒汉式(线程不安全 同步代码块 不可用)
 *
 * @author: https://javaweixin6.blog.csdn.net/
 * 创建时间:2020/9/6 19:26
 * Version 1.0
 */
public class Singleton5 {

    private static Singleton5 INSTANCE ;

    /**
     * 单例模式的构造方法都是私有的, 防止其他对象new
     */
    private Singleton5() {
        //完成初始化等操作...
    }

    /**
     * 返回单例模式对象
     * @return
     */
    public static Singleton5 getInstance() {
        if (INSTANCE == null) {
            //懒汉式,  检查是否为空,如果是空, 再初始化.

            //同步代码块
            synchronized (Singleton5.class) {
                INSTANCE = new Singleton5();
            }
        }
        //如果不是空, 则直接返回实例.
        return INSTANCE;
    }
}

此种写法虽然加了synchronized 锁, 但是加的位置不对, 仍然不能保证只创建出一个对象. 与懒汉式的第一种写法 : 懒汉式(线程不安全 )的原因一样, 主要问题还是出现在第27行代码中, 虽然31行代码加上了锁, 但是在还未实例化对象的时候, 两个线程还是可以同时进入27行, 此时实例为null , 都会到31行代码中, 到了31行同步代码块之后, 一个对象创建完实例后, 另外一个对象就可以再创建一个实例了, 就不符合单例模式了.