单例模式的几种实现方法

单例模式是一种常用的软件设计模式,属于GOF23中的创建性模式,也是设计模式中最简单的形式之一。它的核心作用是保证系统中一个类只有一个实例,同时提供一个访问该实例的全局访问点。
优点:单例模式会阻止其他对象实例化其自己的单例对象的副本,从而确保所有对象都访问唯一实例。减少了系统的开销,还可以在系统中设置全局访问点,可以共享资源。
缺点:不能解决删除单个对象的问题,可能无法访问库源代码。
主要有以下几种实现方法:


一.饿汉式(线程安全,调用效率高,但不能够延时加载)

public class Singleton{
	private static Singleton instance = new Singleton();  
	private Singleton(){}	
	//方法不同步,调用效率高
	public static Singleton getInstance(){
		return instance;
	}	
}


类初始化时便创建一次实例,因此会降低内存的使用率,如果仅仅是加载该类,而不调用getInstance(),则会造成资源的浪费。由于JVM只会装载一次该类,不会发生并发访问的问题,因此线程安全。


二.懒汉式(线程安全,调用效率不高,但能够延时加载)
public class Singleton{	
	//一开始不初始化这个对象,即可以延时加载
	private static Singleton instance;  
	private Singleton(){}
	//方法同步,调用效率不低
	public static synchronized Singleton getInstance(){
		if(instance==null){
			instance = new Singleton();
		}
		return instance;
	}	
}


lazy load! 如果不使用synchronized关键字实现同步方法,则线程不安全,在多线程中不能正常工作,使用synchronized便造成效率较低。

三.双重校验锁式(由于JVM底层内部模型的原因,可能会发生问题)

public class Singleton{ 
  	private static Singleton instance = null; 
 	public static Singleton getInstance() { 
    	if (instance == null) { 
      		Singleton s; 
      		synchronized (Singleton.class) { 
        	s = instance; 
        	if (s == null) { 
          	synchronized (Singleton.class) { 
            		if(sc == null) { 
              			s = new Singleton(); 
            		} 
         	} 
          	instance = s; 
        } 
      } 
    } 
    return instance; 
  } 
  private Singleton() { } 
    
}


在JDK1.5之后,双重检校验锁式才能够正常达到单例效果。将同步内容放到if块中,不需要每次获取对象都要进行同步,因此提高了执行效率。


四.静态内部类式(线程安全,调用效率高,而且能够延时加载)

public class Singleton{
	private static class SingletonClassInstance {
		private static final Singleton instance = new Singleton();
	}
	private Singleton(){}
	//方法不同步,调用效率高
	public static Singleton getInstance(){
		return SingletonClassInstance.instance;
	}	
}


instance被static final进行修饰,保证了只有一个实例,而且仅仅被赋值一次,因此线程安全的,并且外部类没有static修饰,因此可以延时加载。具备并发调用效率高与延时加载的好处,是一种很不错的选择。


五.枚举式(线程安全,调用效率高,但不能够延时加载)

public enum Singleton{	
	//单例对象!
	INSTANCE;
	//添加相关方法
	public void singletonMethod(){}	
}


实现比较简单,因为枚举本身便是单例模式,能够避免通过反射与反序列化进行破解单例。缺点便是不具备延时加载。


下面是阻止反射与反序列化破解单例的方法:
通过反射与反序列化可以破解除前四种方式,在构造函数中手动抛出异常可以控制反射破解,对于反序列化则通过readResolve()来进行防止。具体代码如下:

public class Singleton implements Serializable {
	private static Singleton instance;  
	private Singleton(){
		if(instance!=null){
			throw new RuntimeException();
		}
	}
	public static synchronized Singleton getInstance(){
		if(instance==null){
			instance = new Singleton();
		}
		return instance;
	}
	private Object readResolve() throws ObjectStreamException {
		return instance;
	}	
}





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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值