JAVA设计模式之单例模式(单件模式)—Singleton Pattern
1.什么是单例模式?
《Head First 设计模式》中给出如下定义:确保一个类只有一个实例,并提供一个全局访问点。
关键词:唯一实例对象。
2.单例模式的实现方式:
2.1 懒汉式
对于实例做懒加载处理,即在客户第一次使用时再做创建,所以第一次获取实例的效率会稍微低一些。
/**
* 懒汉式
* @author Lsj
*/
public class LazySingleton { private static LazySingleton instance; /**
* 获取单一实例对象—非同步方法
* @return
*/
public static LazySingleton getInstance(){
if(instance == null){
try {
TimeUnit.NANOSECONDS.sleep(1);//为了使模拟效果更直观,这里延时1ms,具体看时序图
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
instance = new LazySingleton();
}
return instance;
} }
这种创建方式可以延迟加载、但是在多线程环境下获取到的实例可能并非唯一的,具体见如下验证:
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit; /**
* 懒汉式
* @author Lsj
*/
public class LazySingleton { private static LazySingleton instance; /**
* 获取单一实例对象—非同步方法
* @return
*/
public static LazySingleton getInstance(){
if(instance == null){
try {
TimeUnit.NANOSECONDS.sleep(1);//为了使模拟效果更直观,这里延时1ms,具体看时序图
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
instance = new LazySingleton();
}
return instance;
} /**
* 增加同步锁
* 避免多线程环境下并发产生多个实例可能的同时,会带来性能上的损耗。
* 事实上只有第一次创建时需要这么做,但后续依然通过加锁获取单例对象就有点因小失大了。
* @return
*/
public synchronized static LazySingleton getInstanceSyn(){
if(instance == null){
try {
TimeUnit.MILLISECONDS.sleep(1);//为了使模拟效果更直观,这里延时1ms,具体看时序图
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
instance = new LazySingleton();
}
return instance;
} public static void main(String[] args) throws InterruptedException {
//模拟下多线程环境下实例可能不唯一的情况
CountDownLatch startSignal = new CountDownLatch(1);
for(int i=0;i<2;i++){//模拟2个线程
Thread t = new Thread(new MyThread(startSignal));
t.setName("thread " + i);
t.start();
}
Thread.sleep(1000);
startSignal.countDown();
} } class MyThread implements Runnable { private final CountDownLatch startSignal; public MyThread(CountDownLatch startSignal){
this.startSignal = startSignal;
} public void run() {
try {
System.out.println("current thread : " + Thread.currentThread().getName() + " is waiting.");
startSignal.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
LazySingleton l = LazySingleton.getInstance();
System.out.println(l);
} }
从验证结果可以看出两个线程同时获取实例时,得到的并非同一个实例对象:
2.2 懒汉式(+同步锁)
public synchronized static LazySingleton getInstanceSyn(){
if(instance == null){
instance = new LazySingleton();
}
return instance;
}
在上述懒汉式的获取对象方法上做出一些改变,给获取实例的方法加上synchronized同步锁, 但是这种做法在多次调用获取实例方法的情况下会带来性能上的损耗。
事实上只有第一次创建实例时需要这么做,但后续依然通过加锁获取单例对象就有点因小失大了。
2.3 饿汉式
顾名思义、在类加载时就将唯一实例一并加载,后续只需要获取就可以了。
/**
* 饿汉式
* @author Lsj
*/
public class HungrySingleton { private static final String CLASS_NAME = "HungrySingleton"; private static final HungrySingleton instance = new HungrySingleton(); static{
System.out.println("类加载时创建:"+instance);//这里可以看到类加载后,优先加载上方的静态成员变量
} private HungrySingleton(){ } public static HungrySingleton getInstance(){
return instance;
} public static void main(String[] args) throws ClassNotFoundException {
System.out.println(HungrySingleton.CLASS_NAME);//可以看到,这里仅仅是打印HungrySingleton的静态常量,但实例依然被初始化了。
System.out.println("==========分割线==========");
HungrySingleton instance1 = HungrySingleton.getInstance();
System.out.println(instance1);
HungrySingleton instance2 = HungrySingleton.getInstance();
System.out.println(instance2);
} }
运行结果:
从结果可以看到,这种获取单例的方式是线程安全的,JVM保障在多线程情况下一定先创建此实例并且只做一次实例化处理,但是这种情况没有做到懒加载,比如只是引用此类中的一个静态成员变量(常量),此实例在类加载时也一起被初始化了,如果后续应用中不使用这个对象,则会造成资源浪费,占用内存。
2.4 双重检查加锁
此方式可以看做是在懒汉式(+同步锁)方式上的进一步提升,从代码上可以看出主要是针对创建的过程加同步锁。
/**
* 通过双重检查的方式创建及获取单例对象
* @author Lsj
*/
public class DoubleCheckedLockingSingleton { private volatile static DoubleCheckedLockingSingleton instance; private DoubleCheckedLockingSingleton(){} public static DoubleCheckedLockingSingleton getInstance(){
if(instance == null){
synchronized (DoubleCheckedLockingSingleton.class) {
if(instance == null){
instance = new DoubleCheckedLockingSingleton();
}
}
}
return instance;
} }
这种方式可以大大减少2.2方法中获取实例时不必要的同步操作,需要注意的是:静态成员变量中定义的volatile关键字,保证线程间变量的可见性以及防止指令重排序,同时需要的注意必须是jdk1.5及以上版本(volatile关键字在1.5做出了增强处理)。
--这里后续补充不加volatile关键字的危害。
2.5 静态内部类
此方案是基于类初始化的解决方案,JVM在类的初始化阶段,会执行类的初始化。在执行类的初始化期间,JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。
/**
* 以静态内部类的方式来创建获取单例对象
* @author Lsj
*
*/
public class InnerSingleton { private InnerSingleton(){
} public static InnerSingleton getInstance(){
return InnerSingleton.InnerClass.instance;
} static class InnerClass {
private static InnerSingleton instance = new InnerSingleton();
} }
这种方式受益于JVM在多线程环境下对于类初始化的同步控制,这里不再做太详细的说明。
2.6 通过枚举实现单例
《Effective Java》一书中作者Joshua Bloch提倡使用这种方式,这种方式依然是依靠JVM保障,而且可以防止反序列化的时候创建新的对象。
/**
* 通过枚举实现单例模式
* @author Lsj
*
*/
public class EnumSingleton { public static EnumSingleton getInstance(){
return Singleton.INSTANCE.getInstance();
} enum Singleton {
INSTANCE;
private EnumSingleton instance; private Singleton(){
instance = new EnumSingleton();
} private EnumSingleton getInstance(){
return instance;
}
} }
笔者没有这么使用过,暂不做过多描述、实际工作中也很少看到有这么用的,待后续有深入了解后再补充。
3. 总结:
几种单例模式的实现方式中,建议使用4,5,6这三种方式,实际根据使用场景作出选择,另外对于上述提到的几种方式1~5,需要防范通过反射或反序列化的手段创建对象从而使得实例不再唯一,笔者也会在后续会对此作出补充。
参考文献:
《Head Frist设计模式》
《Effective Java》
《Java并发编程的艺术》
JAVA设计模式之单例模式(单件模式)—Singleton Pattern的更多相关文章
- 设计模式 - 单件模式(singleton pattern) 具体解释
版权声明:本文为博主原创文章,未经博主同意不得转载. https://blog.csdn.net/u012515223/article/details/28595349 单件模式(singleton ...
- 设计模式----创建型型模式之单件模式(Singleton pattern)
单件模式,又称单例模式,确保一个类只有一个实例,并提供全局访问点. 单件模式是比较简单且容易理解的一种设计模式.只有一个实例,通常的做法...TODO 类图比较简单,如下所示: 示例代码: 懒汉模式( ...
- C#设计模式——单件模式(Singleton Pattern)
一.概述在软件开发过程中,我们有时候需要保证一个类仅有一个实例,比如在一个电脑用户下只能运行一个outlook实例.这时就需要用到单件模式.二.单件模式单件模式保证一个类仅有一个实例,并提供一个访问它 ...
- 【java设计模式】【创建模式Creational Pattern】单例模式Singleton Pattern
//饿汉式:资源利用率较低(无论是否需要都会创建),性能较高(使用前无需判断实例是否存在,可直接使用) public class EagerSingleton{ private static fina ...
- Java 设计模式(四)-工厂方法模式 (FactoryMethod Pattern)
1 概念定义 1.1 定义 定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 1.2 类型 创建类模式 2 原理特征 2.1 类 ...
- 【java设计模式】【结构模式Structural Pattern】合成模式Composite Pattern
package com.tn.pattern; import java.util.Vector; public class Client { public static void main(Strin ...
- 1.单件模式(Singleton Pattern)
意图:为了保证一个类仅有一个实例,并提供一个访问它的全局访问点. 1.简单实现(多线程有可能产生多个实例) public class CommonSigleton { /// <summary& ...
- 【java设计模式】【创建模式Creational Pattern】建造模式Builder Pattern
package com.tn.pattern; public class Client { public static void main(String[] args) { Director dire ...
- 【java设计模式】【创建模式Creational Pattern】抽象工厂模式Abstract Factory Pattern
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAW0AAABvCAIAAACo3AbKAAALvUlEQVR4nO1dUa7cOA7U/c+zwJxkf4
- 【java设计模式】【行为模式Behavioral Pattern】模板方法模式Template Method Pattern
package com.tn.pattern; public class Client { public static void main(String[] args) { AbstractClass ...
随机推荐
- 【嵌入式硬件Esp32】ESP32 正确下载姿势
程序的正确下载步骤,以8M flash为例子: 一.硬件连接 ESP32 的运行状态主要由 GPIO0 决定 二.ESP32 Flash 地址配置 ESP32 在编译时,通过 make menucon ...
- 【嵌入式硬件Esp32】Eclipse c++切换回英文方法
1.英文版汉化为中文版时是通过:Help-Install New Soft,下载安装中文支持包,重启即可. 2.恢复回英文界面步骤则如下: 2.1.打开安装目录下的eclipse.ini,在文件文件中 ...
- nload 源码安装
nload 1.下载 wget http://www.roland-riegel.de/nload/nload-0.7.4.tar.gz 2.解压 tar zvxf nload-0.7.4.tar.g ...
- 分布式系统领域的 CAP 定理
C 为数据一致性: A 为服务可用性: P 为服务对网络分区故障的容错性. 这三个特性在任何分布式系统中都不能同时满足,最多同时满足两个.
- Mac中设置Sublime快速在终端中使用命令打开项目
工作中用Atom比较多,比较喜欢Atom可以直接在终端中直接输入atom .就能直接打开项目的功能,于是搜索得知sublime text也有这样的功能,下面就简单的配置了一下: sudo ln -s ...
- thinkphp5.0数据导出excel表格
第一步.创建Model类文件(名称自定) 第二步.在类中写入以下代码 <?php namespace Admin\admin\model; use think\Model; class Mark ...
- PAT(B) 1057 数零壹(Java)字符串
题目链接:1057 数零壹 (20 point(s)) 题目描述 给定一串长度不超过 105 的字符串,本题要求你将其中所有英文字母的序号(字母 a-z 对应序号 1-26,不分大小写)相加,得 ...
- C++枚举类型教案
一.枚举类型的应用场景 只需要将需要的变量值一一列举出来,便构成一个枚举类型. 二.枚举类型的定义 ·定义方式: enum 枚举类型名字{枚举常量表}: ·关键字enum:说明接下来定义的是一个枚举类 ...
- 几个有益的 CSS 小知识
样式的顺序 CSS 代码: HTML 代码: 记得之前这是一道比较火的 CSS 考题,当时好像是有不少的人答错(30% 以上) 答案你们应该是知道的. 可以这样提升 CSS 性能 后代选择器 ...
- Scratch编程:画多边形(八)
“ 上节课的内容全部掌握了吗?反复练习了没有,编程最好的学习方法就是练习.练习.再练习.一定要记得多动手.多动脑筋哦~~” 01 — 游戏介绍 这节我们将实现:程序提示用户输入数据,然后根据用户的输入 ...