在不加锁的情况下,实现一个线程安全的单例模式

第一、单例模式的几种实现方式
a.饿汉式(线程安全,调用效率高,但是不能延时加载)

/**
 * 单例模式
 * @author shixiangcheng
 * 2019-07-21
 */
public class Singleton {
    private static final Singleton singleton=new Singleton();
    private Singleton(){
    	System.out.println("==");
    }
    public static Singleton getInstance(){
    	return singleton;
    }
}

b.懒汉式(线程安全,调用效率不高,但是能延时加载)

/**
 * 单例模式
 * @author shixiangcheng
 * 2019-07-21
 */
public class Singleton {
    private static Singleton singleton=null;
    private Singleton(){
    	System.out.println("==");
    }
    //方法同步,调用效率低
    public static synchronized Singleton getInstance(){
        if(singleton==null){
        	singleton=new Singleton();
        }
        return singleton;
    }
}

c.静态内部类实现模式(线程安全,调用效率高,可以延时加载)

/**
 * 单例模式
 * @author shixiangcheng 
 * 2019-07-21
 */
public class Singleton {
	private Singleton() {System.out.println("create instance");}
	private static class SingletonClassInstance {
		private static final Singleton singleton = new Singleton();
	}
	public static Singleton getInstance() {
		return SingletonClassInstance.singleton;
	}
}

d.枚举类(线程安全,调用效率高,不能延时加载,可以天然的防止反射和反序列化调用)

/**
 * 单例模式
 * @author shixiangcheng 
 * 2019-07-21
 */
public enum Singleton {
	//枚举元素本身就是单例
	INSTANCE;
	//添加自己需要的操作
	public void singletonOperation(){
		System.out.println("do");
	}
}

-单例对象 占用资源少,不需要延时加载,枚举 好于 饿汉
-单例对象 占用资源多,需要延时加载,静态内部类 好于 懒汉式

以上几种答案,其实现原理都是利用借助了类加载的时候初始化单例。即借助了ClassLoader的线程安全机制。
所谓ClassLoader的线程安全机制,就是ClassLoader的loadClass方法在加载类的时候使用了synchronized关键字。也正是因为这样, 除非被重写,这个方法默认在整个装载过程中都是同步的,也就是保证了线程安全。
所以,以上各种方法,虽然并没有显示的使用synchronized,但是还是其底层实现原理还是用到了synchronized。
第二、使用CAS技术实现无锁并发,保证线程安全。
点此了解CAS技术:
CAS是项乐观锁技术,当多个线程尝试使用CAS同时更新同一个变量时,只有其中一个线程能更新变量的值,而其它线程都失败,失败的线程并不会被挂起,而是被告知这次竞争中失败,并可以再次尝试。实现单例的方式如下:

import java.util.concurrent.atomic.AtomicReference;
/**
 * 使用CAS保证线程安全
 * @author shixiangcheng
 * 2019-12-20
 */
public class Singleton {
	private static final AtomicReference INSTANCE=new AtomicReference();
	private Singleton(){}
	public static Singleton getInstance(){
		for(;;){
			Singleton singleton=INSTANCE.get();
			if(singleton!=null){
				return singleton;
			}
			singleton=new Singleton();
			if(INSTANCE.compareAndSet(null, singleton)){
				return singleton;
			}
		}
	}
}

用CAS的好处在于不需要使用传统的锁机制来保证线程安全,CAS是一种基于忙等待的算法,依赖底层硬件的实现,相对于锁它没有线程切换和阻塞的额外消耗,可以支持较大的并行度。
CAS的一个重要缺点在于如果忙等待一直执行不成功(一直在死循环中),会对CPU造成较大的执行开销。
另外,如果N个线程同时执行到singleton = new Singleton();的时候,会有大量对象创建,很可能导致内存溢出。

如果觉得对您有帮助,请帮忙点赞。老师说,点赞的人最美丽。

你可能感兴趣的:(多线程,设计模式)