- 浏览: 799934 次
- 性别:
- 来自: 上海
文章分类
- 全部博客 (480)
- Spring (12)
- Hibernate (8)
- Struts2 (4)
- Java 基础-JDK-类-接口-URI-专题研究 (27)
- 线程、线程池、多线程高并发高可用、Socket通信 (15)
- Oracle数据库 (20)
- 一般-前端js-html-其它 (25)
- JYSK-互联网金融、金融科技、支付、公司、新闻等等 (8)
- Ajax-jQuery开源框架 (7)
- Json-轻量级的数据交换格式 (14)
- JavaScript (15)
- Jsp、Servlet、Servlet+JSP+JavaBean开发模式(MVC) (18)
- Html-JavaScript-前端-调用接口 (12)
- Sql Server 2005 (6)
- 正则表达式 (2)
- Java tools (18)
- 加签与验签、加密与解密 (3)
- Ajax技术核心-xmlHttpRequest(简称XHR) (6)
- xml-数据交换格式 (3)
- 信息采集 (1)
- Http - Https - HttpClient - httpCore-SSL-TLS (10)
- HtmlParser (2)
- 标签库 (1)
- SMS (2)
- jxl-导入导出 (4)
- poi-导入导出 (2)
- 定时器Timer+Quartz (6)
- 工作流引擎JBPM3.2.3 (4)
- 工作流引擎JBPM4 (0)
- 数据源-JNDI (0)
- tomcat、weblogic等应用服务器 (6)
- 工作流引擎jbpm5 (1)
- 搜索引擎Lucene (1)
- ant (1)
- 大数据-HBase (2)
- bigtable (0)
- 数据库设计 (4)
- jquery tab (0)
- mybatis (5)
- jquery ui 1.10.3 (5)
- Jboss7 (1)
- 规则引擎drools (0)
- 工作流引擎Activiti5 (0)
- 数据库-用户自定义函数 (0)
- 数据库-存储过程 (2)
- 数据库-视图 (0)
- 数据库-触发器 (0)
- 数据库-sql (2)
- highcharts-图表工具 (1)
- sql server 2008 (6)
- 诗词-工作室 (2)
- 数据割接 (1)
- GIS-地理信息系统 (2)
- RS-遥感技术 (1)
- GPS-全球定位系统 (1)
- java整合flex_RIA开发 (3)
- C#编程语言 (5)
- webservice_axis2_cxf_soap_wsdl (2)
- sql语句 (3)
- Flex_WebService_GIS (25)
- PHP编程语言 (0)
- ExtJS4.2 (1)
- Spring mvc (5)
- EasyUI1.4.2 (16)
- 日期时间工具类 (4)
- 随机数 (1)
- Arcgis api for js (0)
- Mysql数据库 (9)
- 移动互联网 java html5/flash socket netty (0)
- API接口 (1)
- AndroidStudio (0)
- Git (2)
- Maven (5)
- IDEA (0)
- 大数据-Hadoop (2)
- JPA (0)
- Spring boot (4)
- JSF (0)
- nginx_lua_module_redis (2)
- Activiti (1)
- bootstrap (1)
- AngularJS (10)
- 数据库-索引 (1)
- Linux及其连接工具SSH (4)
- java日志管理 (2)
- islider滑动控件 (1)
- jquery (1)
- 异常处理Exception (1)
- 秒杀与类秒杀系统 (1)
- 连接数据库、数据库连接池 (4)
- 数据库-临时表 (1)
- 软件设计模式-单例、多例、代理、工厂、观察者 (3)
- 集合框架 (5)
- 人工智能--Artificial intelligence、神经网络算法、机器学习 (1)
- 分布式应用 (1)
- SOA服务-Dubbo框架-Thrift框架 (2)
- Zookeeper分布式服务框架 (2)
- intellij idea (1)
- python编程语言 (0)
- 消息队列_MQ (0)
- 消息队列_RabbitMQ (2)
- 消息队列_ActiveMQ (1)
- 消息队列_Kafka (2)
- 缓存_Redis (4)
- 缓存_Memcache (0)
- 缓存_Ehcache (0)
- ivy-ivyde (1)
- google-protocol buffers (1)
- 正向代理-正向代理服务器 (1)
- 反向代理-反向代理服务器 (1)
- JVM内存模型 (0)
- Thunder框架 (1)
- NIO-非阻塞式IO (0)
- 软件测试、性能测试 (1)
- 序列化、Serializable接口、Externalizable接口 (3)
- 线程池-ExecutorService-ThreadPoolExecutor (1)
- web.xml (1)
- java开发-java工具-实用工具网站 (6)
- 医疗 (1)
- Filter-过滤器 (2)
- Unicode码-双字节字符编码 (1)
- OpenResty (1)
- 计算机网络 (1)
- eclipse_myeclipse_intellij idea (3)
- Enum (1)
- 大数据--Big Data (1)
- 云计算--Cloud computing (1)
- Elastic-Job (1)
- Redis (2)
- 文件流-IO操作 (6)
- 计算机基础知识 (1)
- Hessian-二进制RPC协议 (1)
- String类 (3)
- BigDecimal类 (1)
- java重要接口 (1)
- ReactJS (1)
- 跨域问题 (0)
- Map (1)
- 注解 (1)
- ASCII码-单字节字符编码 (1)
- 微服务、微服务架构 (2)
- RPC协议、RPC服务、RPC框架 (0)
- java反射 (1)
- java项目之classpath (1)
- 经典算法-树 (1)
- listener-监听器 (1)
- Interceptor-拦截器 (1)
- pojo javabean (2)
- 计算机科学与技术-进阶 (1)
- 代码规范与文档编写 (1)
- UML-统一建模语言 (1)
- 对接微信、支付宝 (3)
- 压力测试 (1)
- 办公软件-Excel (1)
- 办公软件-PPT (0)
- UTF8、GBK编码 (1)
- 微服务架构:Spring Cloud架构-Dubbo架构 (6)
- Nginx (1)
- 点滴业务 (1)
- form表单-json数据-转换与接口调用 (1)
- Junit单元测试 (1)
- 大数据-Spark (1)
- 大数据-Storm (1)
- 数据库事务-Spring事务 (0)
- elasticsearch (1)
- windows (1)
最新评论
参考博客:
1.单例和多例的区别
http://www.cnblogs.com/zhangliang88/p/5388472.html
2.Java:单例模式的七种写法
http://www.blogjava.net/kenzhh/archive/2013/03/15/357824.html
3.Java Singleton
http://blog.csdn.net/penngrove/article/details/5753977
==============================================================================
【单例类的5种写法】
==============================================================================
1、饿汉方式
2、懒汉方式
3、静态内部类方式
4、双重校验锁方式
5、枚举方式
====================================================================
【用Reflection + SetAccessable()来攻击单例,如果能创建出两份单例,就认为攻击成功】
====================================================================
输出结果console截图:
1.单例和多例的区别
http://www.cnblogs.com/zhangliang88/p/5388472.html
2.Java:单例模式的七种写法
http://www.blogjava.net/kenzhh/archive/2013/03/15/357824.html
3.Java Singleton
http://blog.csdn.net/penngrove/article/details/5753977
==============================================================================
【单例类的5种写法】
==============================================================================
1、饿汉方式
/** * 饿汉,初始化时即生成 * @author franciswmf *这种方式基于classloder机制避免了多线程的同步问题,不过,instance在类装载时就实例化, *虽然导致类装载的原因有很多种,在单例模式中大多数都是调用getInstance方法, *但是也不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance显然没有达到lazy loading的效果。 */ public class TraditionalSingleton { private TraditionalSingleton(){ System.out.println("TraditionalSingleton constructor execute"); } private static TraditionalSingleton singleton=new TraditionalSingleton(); public static TraditionalSingleton getInstance(){ return singleton; } }
2、懒汉方式
/** * 懒汉,线程安全(但效率低) * @author franciswmf *这种写法能够在多线程中很好的工作,而且看起来它也具备很好的lazy loading, *但是,遗憾的是,效率很低,99%情况下不需要同步。 */ public class LazySingleton { private static LazySingleton instance; private LazySingleton(){ System.out.println("LazySingleton constructor execute"); } public static synchronized LazySingleton getInstance(){//加synchronized同步关键字 if(null==instance){ instance=new LazySingleton(); } return instance; } }
3、静态内部类方式
/** * 静态内部类方式 * @author franciswmf *这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程, *它跟第三种和第四种方式不同的是(很细微的差别):第三种和第四种方式是只要Singleton类被装载了, *那么instance就会被实例化(没有达到lazy loading效果),而这种方式是Singleton类被装载了, *instance不一定被初始化。因为SingletonHolder类没有被主动使用,只有显示通过调用getInstance方法时, *才会显示装载SingletonHolder类,从而实例化instance。想象一下,如果实例化instance很消耗资源, *我想让他延迟加载,另外一方面,我不希望在Singleton类加载时就实例化,因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载, *那么这个时候实例化instance显然是不合适的。这个时候,这种方式相比第三和第四种方式就显得很合理。 */ public class StaticInnerClassSingleton { private StaticInnerClassSingleton(){ System.out.println("StaticInnerClassSingleton constructor execute"); } private static class InnerFactory{ private static final StaticInnerClassSingleton instance=new StaticInnerClassSingleton();//内部类 } public static StaticInnerClassSingleton getInstance(){ return InnerFactory.instance; } }
4、双重校验锁方式
/** * 双重校验锁 * @author franciswmf *这个是Singleton3方式的升级版,俗称双重检查锁定, *详细介绍请查看:http://www.ibm.com/developerworks/cn/java/j-dcl.html *在JDK1.5之后,双重检查锁定才能够正常达到单例效果。 */ public class DoubleCheckSingleton { private DoubleCheckSingleton(){ System.out.println("DoubleCheckSingleton constructor execute"); } private volatile static DoubleCheckSingleton singleton; // public static DoubleCheckSingleton getInstance(){ if(singleton==null){ synchronized(DoubleCheckSingleton.class){ if(singleton==null){ singleton=new DoubleCheckSingleton(); } } } return singleton; } }
5、枚举方式
/** * 枚举 * 这种方式是Effective Java作者Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象, * 可谓是很坚强的壁垒啊,不过,个人认为由于1.5中才加入enum特性,用这种方式写不免让人感觉生疏,在实际工作中,我也很少看见有人这么写过。 * @author franciswmf * */ public enum EnumSingleton { INSTANCE; EnumSingleton(){ System.out.println("EnumSingleton constructor execute"); } }
====================================================================
【用Reflection + SetAccessable()来攻击单例,如果能创建出两份单例,就认为攻击成功】
====================================================================
public class ReflectionAttack { /** * 1-TraditionalSingleton-饿汉方式 * @throws Exception */ private static void attackTraditionalSingleton() throws Exception{ Class<TraditionalSingleton> class_a=TraditionalSingleton.class; Constructor<TraditionalSingleton> constructor_a=class_a.getDeclaredConstructor(); constructor_a.setAccessible(true); TraditionalSingleton obj=constructor_a.newInstance(); obj=TraditionalSingleton.getInstance(); } /** * 2-LazySingleton-懒汉方式 * @throws Exception */ private static void attackLazySingleton() throws Exception{ Class<LazySingleton> class_a=LazySingleton.class; Constructor<LazySingleton> constructor_a=class_a.getDeclaredConstructor(); constructor_a.setAccessible(true); LazySingleton obj=constructor_a.newInstance(); obj=LazySingleton.getInstance(); } /** * 3-StaticInnerClassSingleton-静态内部类方式 * @throws Exception */ private static void attackStaticInnerClassSingleton() throws Exception{ Class<StaticInnerClassSingleton> class_a=StaticInnerClassSingleton.class; Constructor<StaticInnerClassSingleton> constructor_a=class_a.getDeclaredConstructor(); constructor_a.setAccessible(true); StaticInnerClassSingleton obj=constructor_a.newInstance(); obj=StaticInnerClassSingleton.getInstance(); } /** * 4-DoubleCheckSingleton-双重校验锁方式 * @throws Exception */ private static void attackDoubleCheckSingleton() throws Exception{ Class<DoubleCheckSingleton> class_a=DoubleCheckSingleton.class; Constructor<DoubleCheckSingleton> constructor_a=class_a.getDeclaredConstructor(); constructor_a.setAccessible(true); DoubleCheckSingleton obj=constructor_a.newInstance(); obj=DoubleCheckSingleton.getInstance(); } /** * 5-EnumSingleton-枚举方式 *Java的单例模式在Effective Java里面有权威的做法,就是用Enum。这是最完美的做法。它 *利用Java自身语言机制保证了内存中只有一份拷贝,同时它也让那些想通过Reflection + *setAccessable()的攻击单例的做法失败。 * @throws Exception */ private static void attackEnumSingleton() throws Exception{ Class<EnumSingleton> class_a=EnumSingleton.class; Constructor<EnumSingleton> constructor_a=class_a.getDeclaredConstructor(); constructor_a.setAccessible(true); EnumSingleton obj=constructor_a.newInstance(); obj=EnumSingleton.INSTANCE; } public static void main(String[] args) throws Exception { attackTraditionalSingleton();//输出2次 attackLazySingleton();//输出2次 attackStaticInnerClassSingleton();//输出2次 attackDoubleCheckSingleton();//输出2次 attackEnumSingleton();//抛出异常:NoSuchMethodException } }
输出结果console截图:
相关推荐
Java中的单例设计模式是一种确保一个类只有一个实例并提供一个全局访问点的设计模式。它主要分为两种实现方式:饿汉式(Eager Initialization)和懒汉式(Lazy Initialization)。 ### 1. 饿汉式单例设计模式 饿汉...
总结,Java单例设计模式通过饿汉式和懒汉式实现,饿汉式在类加载时创建实例,适用于不需要延迟加载的情况;懒汉式在首次调用时创建,但在多线程环境下需要额外的同步措施以保证线程安全。在实际应用中,应根据具体...
Java中的单例设计模式是一种常用的设计模式,它确保一个类只有一个实例,并且提供一个全局访问点。单例模式常用于管理资源,如配置信息的读取,或者在系统中需要一个全局协调者的情况下。 单例设计模式有两大关键点...
Java 单例设计模式主要分为两种实现方式:饿汉式和懒汉式。这两种方式都是为了确保一个类只有一个实例,并且提供全局访问点。 **饿汉式**: 饿汉式单例在类加载时就完成了实例化,因此是静态常量的方式,确保了线程...
在Java中,单例模式有两种常见的实现方式:饿汉式和懒汉式。 1. **饿汉式**: 饿汉式单例在类加载时即创建了实例,因此它是线程安全的。这种方式保证了类加载后就立即初始化单例对象,避免了多线程环境下的同步...
这种模式在Java中有两种常见的实现方式:饿汉式和懒汉式。 1. 饿汉式单例: 饿汉式单例在类加载时就完成了初始化,因此类加载时就创建了单例对象。这种方式称为预先加载方式,它保证了线程安全,因为对象的创建在类...
java 单例模式(懒汉式与饿汉式) java 单例模式是一种常用的软件设计模式。在它的可信结构中只包含一个被实例化单例的特别类。通过单例设计模式可以把整系统中的一个类只有一个实例。单例设计模式又分为两种方式,...
Java 单例模式(懒汉式与饿汉式) Java 单例模式是一种常用的软件设计模式,在它的可信结构中只包含一个被实例化单例的特殊类。通过单例设计模式可以把整系统中的一个类只有一个实例。单例设计模式又分为两种方式,...
本文将详细讨论四种常见的单例实现方式:饿汉模式、懒汉模式、双重检查锁定(DCL)单例模式以及枚举单例。 1. **饿汉模式**: 饿汉模式是在类加载时就完成了实例化,避免了线程同步问题。这种方式简单且安全,但...
单例模式是软件设计模式中的一种,用于控制类的实例化过程,确保一个类只有一个实例,并提供全局访问点。在Java中,实现单例模式有多种方法,每种方法都有其特点和适用场景。以下是对这六种常见单例模式实现方式的...
在 Java 中,单例模式的写法有好几种,主要有懒汉式单例、饿汉式单例、登记式单例等。 懒汉式单例是一种常见的单例模式实现方式,它在第一次调用的时候实例化自己。下面是懒汉式单例的四种写法: 1、基本懒汉式...
Java 单例模式是一种设计模式,它的核心思想是确保一个类只有一个实例,并提供一个全局访问点。这种模式在资源管理、缓存、日志记录等场景中广泛应用,例如在 JDBC 连接数据库时,通常会采用单例模式来管理数据库...
在Java中,单例模式可以通过多种方式实现,包括懒汉式、饿汉式、双重检查锁定和静态内部类方法等。今天,我们主要介绍了Java单例模式实现静态内部类方法示例,涉及构造函数私有化等相关内容。 单例模式的定义 单例...
单例模式是一种常用的软件设计模式,它保证一个类只有一个实例,并提供一个全局访问点。在IT行业中,尤其是在处理资源密集型任务如数据库连接时,单例模式被广泛应用。数据库连接池就是这种应用的一个典型例子。 ...
Java中的单例模式是一种常用的软件设计模式,它保证一个类只有一个实例,并提供全局访问点。在Java编程中,单例模式常用于控制资源的访问,比如数据库连接池、线程池或者日志对象等。本篇文章将深入探讨如何在Java中...
单例模式是软件设计模式中的一种经典模式,用于确保一个类只有一个实例,并提供一个全局访问点。在Java中,有多种实现单例模式的方法,每种都有其特点和适用场景。接下来,我们将深入探讨这些实现方式。 首先,我们...
实现单例模式主要有两种方式:饿汉式和懒汉式。 ### **饿汉式单例模式** 饿汉式单例模式在类加载时就完成了实例化,因此也称为静态初始化。这种方式保证了线程安全,但可能会造成不必要的资源浪费,因为即使未使用...
单例模式分为两种主要实现方式:饿汉模式和懒汉模式。 1. 饿汉模式(Eager Initialization): 饿汉模式的特点是在类加载时就完成了实例化,因此它是线程安全的。在给出的例子中,`SingleTon`类的静态私有实例`st`...
单例模式是软件设计模式中的一种,用于控制类的实例化过程,确保一个类在整个程序运行期间只有一个实例存在。这种模式常用于管理共享资源,如数据库连接、缓存或者线程池等,以减少资源消耗并提高性能。单例模式有...