设计模式之单例模式

一、单例模式

1.1 饿汉式

  • 无须考虑多个线程同时访问的问题;调用速度和反应时间优于懒汉式单例;
  • 资源利用效率不及懒汉式单例;
  • 系统加载时间可能会比较长。
// 饿汉式
public class EagerSingleton {

	// 类加载时,就创建对象(进行资源分配)
	private static EagerSingleton instance = new EagerSingleton();
	
	private EagerSingleton() {
	}
	
	/**
	 * 性能比懒汉式好一些
	 *
	 * @return
	 */
	public static EagerSingleton getInstance() {
		return instance;
	}
}

1.2 懒汉式

1.2.1 多线程不安全

package design.singleton;

/**
 * 类是模板,用来创建多个实例(对象);
 * 有时希望只能创建出一个唯一的实例
 * 单例模式
 *
 */

//懒汉式 - 延迟加载
public class LazySingleton {

	// 类变量,类加载时创建的唯一的一份
	private static LazySingleton instance = null;
	
	// 封装在内部的状态或方法,它们也是 全局唯一 的
	int count;
	
	// 构造方法 私有,外部不可调用
	private LazySingleton() {
		count = 0;
	}
	
	public void add() {
		++count;
	}
	
	public int count() {
		return count;
	}
	
	/*
	 * 公共的静态方法,通过类名调用
	 * 多线程时需要加上同步关键字 synchronized !!!
	 */
	public static LazySingleton getInstance() {
		if(instance==null) {
			// 第一次调用时,创建对象,延迟了资源加载时间
			// 需要较长时间
			// 考虑如果多个对象同时访问将导致创建多个实例对象,how to do?
			instance = new LazySingleton();
		}
		return instance;
	}
	
}

1.2.2 同步锁:锁方法

public class LazySingletonLock1 {

	private static LazySingletonLock1 instance = null;
	
	private LazySingletonLock1() {
	}
	
	// 同步关键字 synchronized
	// 锁方法
	public static synchronized LazySingletonLock1 getInstance() {
		if(instance==null) {
			instance = new LazySingletonLock1();
		}
		return instance;
	}
}

1.2.3 同步锁:锁代码段

public class LazySingletonLock2 {

	private static LazySingletonLock2 instance = null;
	
	private LazySingletonLock2() {
	}
	
	// 同步关键字 synchronized
	public static LazySingletonLock2 getInstance() {
		if(instance==null) {
			// 锁代码段
			synchronized(LazySingletonLock2.class) {
				instance = new LazySingletonLock2();
			}
		}
		return instance;
	}
}

1.2.4 双重检查锁

public class LazySingletonDoubleCheckLock {

	// volatile 关键字 :1、多线程之间可见性;2、禁止指令重排序。
	private volatile static LazySingletonDoubleCheckLock instance = null;
	
	private LazySingletonDoubleCheckLock() {
	}
	
	// 双重检查锁
	public static LazySingletonDoubleCheckLock getInstance() {
		//第一重判断
		if(instance==null) {
			// 锁代码段
			synchronized(LazySingletonDoubleCheckLock.class) {
				// 第二重判断
				if(instance==null) {
					// 创建单例实例
					instance = new LazySingletonDoubleCheckLock();					
				}
			}
		}
		return instance;
	}
}

1.3 基于静态内部类

// 方案三:基于静态内部类
// 发起人:Crazy Bob(Bob Lee)
// 静态内部类不会在单例加载时就加载,而是在调用getInstance()方法时才进行加载,达到了类似懒汉模式的效果,而这种方法又是线程安全的
public class Singleton3 {

	public static class SingletonHolder{
		private static Singleton3 instance = new Singleton3();
	}
	
	private Singleton3() {
	}
	
	public static Singleton3 getInstance() {
		return SingletonHolder.instance;
	}

}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值