单例饿汉式和饱汉式各自的有缺点(转)

单例模式应用于一个类只有一个实例的情况,并且为其实例提供一个全局的访问点。

特点

1.一个类只有一个实例

2.自己创建这个实例

3.整个系统只能用这个实例

应用场景

外部资源:每台计算机有若干个打印机,但只能有一个PrinterSpooler,以避免两个打印作业同时输出到打印机。

内部资源:大多数软件都有一个(或多个)属性文件存放系统配置,这样的系统应该有一个对象管理这些属性文件。

实现方式

1.饿汉式:单例实例在类装载时就构建,急切初始化。(预先加载法)

/**
 * 饿汉式(推荐)
 *
 */
public class Singleton1 {

	private Singleton1() {
	}

	public static Singleton1 instance = new Singleton1();

	public Singleton1 getInstance() {
		return instance;
	}

}
优点 1.线程安全 
2.在类加载的同时已经创建好一个静态对象,调用时反应速度快
缺点 资源效率不高,可能getInstance()永远不会执行到,但执行该类的其他静态方法或者加载了该类(class.forName),那么这个实例仍然初始化

2.懒汉式:单例实例在第一次被使用时构建,延迟初始化。

class Singleton2 {
	private Singleton2() {
	}

	public static Singleton2 instance = null;

	public static Singleton2 getInstance() {
		if (instance == null) {
              //多个线程判断instance都为null时,在执行new操作时多线程会出现重复情况
			instance = new Singleton2();
		}
		return instance;
	}
}

懒汉式在单个线程中没有问题,但在多线程就可能会出现两个或多个Singleton2实例情况,

虽然后面实例化的Singleton2会覆盖前面实例化的Singleton2,但最好避免这样的情况。

改进方式就是加锁synchornized

class Singleton3 {
	private Singleton3() {
	}

	public static Singleton3 instance = null;

	public static synchronized Singleton3 getInstance() {
		if (instance == null) {
			instance = new Singleton3();
		}
		return instance;
	}
}
优点 资源利用率高,不执行getInstance()就不会被实例,可以执行该类的其他静态方法
缺点 第一次加载时不够快,多线程使用不必要的同步开销大

3.双重检测

class Singleton4 {
	private Singleton4() {
	}

	public static Singleton4 instance = null;

	public static Singleton4 getInstance() {
		if (instance == null) {
			synchronized (Singleton4.class) {
				if (instance == null) {
					instance = new Singleton4();
				}
			}
		}
		return instance;
	}
}
优点 资源利用率高,不执行getInstance()就不被实例,可以执行该类其他静态方法
缺点 第一次加载时反应不快,由于java内存模型一些原因偶尔失败

4.静态内部类

class Singleton5 {
	private Singleton5() {
	}

	private static class SingletonHelp {
		static Singleton5 instance = new Singleton5();
	}

	public static Singleton5 getInstance() {
		return SingletonHelp.instance;
	}
}
优点 资源利用率高,不执行getInstance()不被实例,可以执行该类其他静态方法
缺点 第一次加载时反应不够快

总结:一般采用饿汉式(1),若对资源十分在意可以采用静态内部类(4),不建议采用懒汉式及双重检测(2、3)

时间: 2024-11-06 14:35:51

单例饿汉式和饱汉式各自的有缺点(转)的相关文章

C++两种单例(饿汉式,懒汉式)

俄汉式 #include <iostream> using namespace std; class A{ public:     static A& getInstance(void){         return s_instance;     } private:     A(int data=0):m_data(data){}     A(A const& that);     int m_data;     static A s_instance; }; A A::

单例模式的简单描述(饿汉式,饱汉式,双重锁模式)

一.什么时候使用单例模式: 当实例存在多个会引起程序逻辑错误的时候 二.好处: 1.减少内存的占用 2.单例模式会阻止其他对象实例化其自己的单例对象的副本,从而确保所有对象都访问唯一实例. 3.因为类控制了实例化过程,所以类可以灵活更改实例化过程 三.缺点: 1.开销 虽然数量很少,但如果每次对象请求引用时都要检查是否存在类的实例,将仍然需要一些开销.可以通过使用静态初始化解决此问题. 2.可能的开发混淆 使用单例对象(尤其在类库中定义的对象)时,开发人员必须记住自己不能使用new关键字实例化对

JAVA中的饿汉式和饱汉式单例模式及jdk中Runtime类的单例模式实现方式详解

一.描述 单例模式是一种非常常见的设计模式,即一个类只能有一个对象(实例),一般通过将该类的构造器私有化,来阻止在该类外创建该类的对象,并提供给外界一个唯一的对象(这个对象在该类中创建). java中的单例模式常见的有两种实现方式,一种是恶汉方式,即将该类对象用static休息并且在类加载的时候进行初始化:另一种是饱汉方式,在程序中需要用到该对象的时候才初始化,一旦初始化一次就不会再重新生成该对象. JDK中的Runtime类其实也是一种单例模式,而且其采用的是饿汉的方式. 二.源代码 pack

单例模式(懒汉式单例、饿汉式单例、登记式单例)

单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一.这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式. 这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建.这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象. 注意: 1.单例类只能有一个实例. 2.单例类必须自己创建自己的唯一实例. 3.单例类必须给所有其他对象提供这一实例. 介绍 意图:保证一个类仅有一个实例,并提供一个访问它的全局访问点.

java中你确定用对单例了吗?

作为程序猿这种特殊物种来说,都掌握了一种特殊能力就是编程思想,逻辑比较谨慎,但是有时候总会忽略到一些细节,比如我,一直以来总觉得Singleton是设计模式里最简单的,不用太在意,然而就是因为这种不在意在开发中吃亏了.真的too young to simple. 好不扯淡了,直入主题. 在代码的世界里发现有各种写法的单例,有人说单例有5种,6种,7种- 对于单例的分类这点必须规范下,首先这么多种的分类是根据什么来定义的,基准是什么?否则怎么会有那么多写法. 因此归纳下来,从延迟加载和执行效率的角

【java设计模式】之 单例(Singleton)模式

1. 单例模式的定义 单例模式(Singleton Pattern)是一个比较简单的模式,其原始定义如下:Ensure a class has only one instance, and provide a global point of access to it. 即确保只有一个实例,而且自行实例化并向整个系统提供这个实例.单例模式的通用类如下图所示: Singleton类称为单例类,通过使用private的构造函数确保了在一个应用中只产生一个实例,并且是自行实例化的(在Singleton中

Unity3D 单例(singleton)管理类

在Unity3D中,有什么好的方法去创建一个单例游戏管理类,可以像一个全局类的静态变量一样到处访问? 在Unity中有什么接口吗?我是否要把这个脚本添加到一个物体上呢?这个类可以仅仅放在文件夹里不用添加到场景里吗? 通常来说视情况而定,常用的两种单例类. (1)组件式的添加在物体上. (2)不从MonoBehaviour继承的独立类. public class MainComponentManger { private static MainComponentManger instance; p

Struts2和SpringMVC的action是单例还是原型的?

struts2的acion单独使用的时候应是多例的,也就是原型(prototype). 因为它是基于类开发的,它的三种获取页面传参的方式都是通过成员变量的方式来接受的. 如果用struts2框架基于方法的形式进行开发(一个方法对应一个请求处理的话),那么意味着这多个方法都可以共享成员变量.这时候,那么就可能会出现并发问题:不同的请求对同一个实例中的成员变量一起操作,出现数据安全问题.比如前一个人的密码可能被后面的人看到,提交的数据被修改等. 这就是为什么struts2为什么是多例的原因. 值得注

(单例设计模式之一)饿汉式的反射与反序列化漏洞

1.闲话少说,直接上代码. import java.io.Serializable;//饿汉式public class Singleton01 implements Serializable{    //1.私有的属性    private static Singleton01 instance=new Singleton01();    //2.私有的构造器    private Singleton01(){}    //3.共有的get()方法    public static  Singl