一、单例设计模式介绍

  所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例, 并且该类只提供一个取得其对象实例的方法(静态方法)

  例如:Hibernate的SessionFactory,它充当数据存储源的代理,并负责创建Session对象。SessionFactory并不是轻量级的,一般情况下,一个项目通常只需要一个SessionFactory就够,这里就会使用到单例模式

二、单例设计模式的七种方式

  (1)饿汉式(静态常量)

    步骤:① 构造器私有化(防止new)

       ② 在类的内部创建对象

         ③ 向外暴露一个静态的公共方法。getInstance

    代码实现:

 1 /**
2 * 单例设计模式
3 * 饿汉式(静态变量)
4 */
5 public class Singleton01 {
6 //构造器私有化,防止外部创建对象
7 private Singleton01() {
8 }
9
10 //在本类内部创建对象实例
11 private final static Singleton01 instance = new Singleton01();
12
13 //对外提供公有静态方法返回实例对象
14 public static Singleton01 getInstance() {
15 return instance;
16 }
17 }
18
19
20 public class SingletonTest01 {
21 public static void main(String[] args) {
22 Singleton01 singleton01 = Singleton01.getInstance();
23 Singleton01 singleton02 = Singleton01.getInstance();
24 System.out.println(singleton01.equals(singleton02));//true
25 }
26 }

    输出结果:

    

    分析:

    优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题

    缺点:在类装载的时候就完成实例化,没有达到懒加载的效果。如果从始至终从未使用过这个实例,则会造成内存的浪费

    这种方式基于类装载机制避免了多线程的同步问题,不过,instance在类装载时就实例化,在单例模式中大多数都是调用getInstance方法, 但是导致类装载的原因有很多种,因此不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance就没有达到懒加载的效果

    结论:这种单例模式可用,但是可能造成内存浪费

  (2)饿汉式(静态代码块)

    与上面步骤相似,不过将类实例化的过程放在了静态代码块中

    代码实现:

 1 /**
2 * 单例设计模式
3 * 饿汉式(静态代码块)
4 */
5 public class Singleton02 {
6 //构造方法私有化,防止外部new
7 private Singleton02() {
8 }
9
10 //本类内部声明对象
11 private static Singleton02 instance;
12
13 //在静态代码块中创建单例对象
14 static {
15 instance = new Singleton02();
16 }
17
18 //提供公有方法getInstance返回实例
19 public static Singleton02 getInstance() {
20 return instance;
21 }
22 }
23
24 public class Singleton02Test {
25 public static void main(String[] args) {
26 Singleton02 singleton02 = Singleton02.getInstance();
27 Singleton02 singleton03 = Singleton02.getInstance();
28 System.out.println(singleton02.equals(singleton03));//true
29 }
30 }

    输出结果:

    

    分析:

    这种方式和上面的方式其实类似,只不过将类实例化的过程放在了静态代码块中,也是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。优缺点和上面是一样的

    结论:这种单例模式可用,但是可能造成内存浪费

  (3)懒汉式(线程不安全)

    为了解决内存浪费的问题,我们将getInstance的执行流程改为调用方法再返回实例,通俗的讲就是懒加载

    代码实现:

 1 /**
2 * 单例设计模式
3 * 懒汉式(线程不安全)
4 * */
5 public class Singleton03 {
6 private static Singleton03 instance;
7
8 private Singleton03() {
9 }
10
11 /**
12 * 当使用到该方法时再去创建实例
13 * */
14 public static Singleton03 getInstance() {
15 if (instance == null) {
16 instance = new Singleton03();
17 }
18 return instance;
19 }
20 }
21
22 public class Singleton03Test {
23 public static void main(String[] args) {
24 Singleton03 singleton03 = Singleton03.getInstance();
25 Singleton03 singleton04 = Singleton03.getInstance();
26 System.out.println(singleton03.equals(singleton04));//true
27 }
28 }

    运行结果:

    

    分析:

    起到了懒加载的效果,但是只能在单线程下使用

    如果在多线程下,一个线程进入了 if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例,所以在多线程环境下不可使用这种方式

    结论:在实际开发中,不要使用这种方式

  (4)懒汉式(线程安全,同步方法)

    要解决线程不安全的问题,我们可以将getInstance方法改成同步执行,一个线程访问一个对象中的synchronized同步代码块时,其他试图访问该对象的线程将被阻塞

    代码实现:

 1 /**
2 * 单例设计模式
3 * 懒汉式(线程安全,同步方法)
4 * */
5 public class Singleton04 {
6 private static Singleton04 instance;
7
8 private Singleton04() {
9 }
10
11 /**
12 * 当使用到该方法时再去创建实例,加入同步代码,解决线程不安全问题
13 * */
14 public static synchronized Singleton04 getInstance() {
15 if (instance == null) {
16 instance = new Singleton04();
17 }
18 return instance;
19 }
20 }
21
22
23 public class Singleton04Test {
24 public static void main(String[] args) {
25 Singleton04 instance01 = Singleton04.getInstance();
26 Singleton04 instance02 = Singleton04.getInstance();
27 System.out.println("懒汉式(线程安全,同步方法):" + instance01.equals(instance02));//true
28 }
29 }

    运行结果:

    

     分析:

    优点:解决了线程安全问题

    缺点:效率太低了,每个线程在想获得类的实例时候,执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了,后面的想获得该类实例,直接return就行了,方法进行同步效率太低

    结论:在实际开发中,不推荐使用这种方式

  (5)懒汉式(双重检查)

    为了同时解决线程安全和懒加载的问题,这里需要使用volatile关键字以及synchronized代码块

    volatile关键字详细解读

    代码实现:

 1 /**
2 * 单例设计模式
3 * 懒汉式(双重检查)
4 */
5 public class Singleton05 {
6 //使instance的变动立即写入到主存中
7 private static volatile Singleton05 instance;
8
9 private Singleton05() {
10 }
11
12 //提供一个静态的公有方法,加入双重检查代码,解决线程安全问题, 同时解决懒加载问题,保证了效率
13 public static Singleton05 getInstance() {
14 //解决懒加载问题
15 if (instance == null) {
16 //解决线程安全问题,保证每次只有一个线程进入该代码块
17 synchronized (Singleton05.class) {
18 if (instance == null) {
19 instance = new Singleton05();
20 }
21 }
22 }
23 return instance;
24 }
25 }
26
27 public class Singleton05Test {
28 public static void main(String[] args) {
29 Singleton05 instance01 = Singleton05.getInstance();
30 Singleton05 instance02 = Singleton05.getInstance();
31 System.out.println("懒汉式(双重检查):" + instance01.equals(instance02));
32 }
33 }

    运行结果:

    

    分析:

    Double-Check(双重检查)概念是多线程开发中常使用到的,如代码中所示,我们进行了两次 if (singleton == null)检查,这样就可以保证线程安全了

    这样,实例化代码只用执行一次,后面再次访问时,判断 if (singleton == null),直接 return 实例化对象,也避免的反复进行方法同步,线程安全,懒加载,效率较高

    结论:在实际开发中,推荐使用这种单例设计模式

  (6)静态内部类

    代码实现:

 1 /**
2 * 单例设计模式
3 * 静态内部类
4 */
5 public class Singleton06 {
6
7 //构造器私有化
8 private Singleton06() {
9 }
10
11 //静态内部类,该类内部有一个静态属性Singleton06
12 private static class SingletonInstance {
13 private static final Singleton06 INSTANCE = new Singleton06();
14 }
15
16 //提供getInstance方法直接返回实例
17 public static Singleton06 getInstance() {
18 return SingletonInstance.INSTANCE;
19 }
20 }
21
22 public class Singleton06Test {
23 public static void main(String[] args) {
24 Singleton06 instance01 = Singleton06.getInstance();
25 Singleton06 instance02 = Singleton06.getInstance();
26 System.out.println("静态内部类:" + instance01.equals(instance02));//true
27 }
28 }

    运行结果:

    

    分析:

    这种方式采用了类装载的机制来保证初始化实例时只有一个线程

    静态内部类方式在Singleton类被装载时并不会立即实例化,而是在需要实例化时,调用getInstance方法,才会装载SingletonInstance类,从而完成Singleton的实例化

    类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM帮助我们保证了线程的安全性,在类进行初始化时,别的线程是无法进入的

    优点:避免了线程不安全,利用静态内部类特点实现延迟加载,效率高

    结论:推荐使用

  (7)枚举

    代码实现:

 1 /**
2 * 单例设计模式
3 * 枚举
4 */
5 public enum Singleton07 {
6 INSTANCE;//属性
7 public void sayOK(){
8 System.out.println("OK ");
9 }
10 }
11
12 public class Singleton07Test {
13 public static void main(String[] args) {
14 Singleton07 instance = Singleton07.INSTANCE;
15 Singleton07 instance01 = Singleton07.INSTANCE;
16 System.out.println("枚举:" + instance.equals(instance01));
17 instance.sayOK();
18 }
19 }

    运行结果:

    

    分析:

    借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象

    这种方式是《Effective Java》作者 Josh Bloch  提倡的方式

    结论:推荐使用

三、总结

  多线程环境下建议使用枚举,静态内部类,双重检查等方式实现单例模式

  单线程环境下可以使用懒汉式和饿汉式的方法实现单例模式

单例设计模式(Singleton)的更多相关文章

  1. 单例设计模式Singleton之懒加载模式(懒汉模式)【原】

    单例设计模式Singleton之懒加载模式(懒汉模式) SingletonLazy.java类 package kingtool; import kingtool.http.IPTool; publi ...

  2. Java学习笔记——单例设计模式Singleton

    单例设计模式:singleton 解决的问题: 确保程序在运行过程中,某个类的实例instance只有一份. 特点: 1 构造函数私有化 2 自己内部声明自己 3 提供一个public方法,负责实例化 ...

  3. Java学习笔记(二十四):单例设计模式singleton

    为什么要使用singleton设计模式? 假设设计了一个操作数组的工具类(Tools),里面有一个锤子的方法(Hammer),如果不使用singleton设计模式,每次想调用Hammer方法都需要ne ...

  4. 单例设计模式singleton

    简单引入 单例设计模式作为最简单,最常用的设计模式.一般是这两中写法,这两种写法教科书所谓的标准写法,但是实际上存在不少问题.后面介绍标准写法,以规避这些问题. 1.懒汉式: /** * 问题在于,当 ...

  5. Java设计模式—单例设计模式(Singleton Pattern)全然解析

    转载请注明出处:http://blog.csdn.net/dmk877/article/details/50311791 相信大家都知道设计模式,听的最多的也应该是单例设计模式,这种模式也是在开发中用 ...

  6. 转:java单例设计模式

    本文转自:http://www.cnblogs.com/yinxiaoqiexuxing/p/5605338.html 单例设计模式 Singleton是一种创建型模式,指某个类采用Singleton ...

  7. 小菜学习设计模式(二)—单例(Singleton)模式

    前言 设计模式目录: 小菜学习设计模式(一)—模板方法(Template)模式 小菜学习设计模式(二)—单例(Singleton)模式 小菜学习设计模式(三)—工厂方法(Factory Method) ...

  8. 设计模式的征途—1.单例(Singleton)模式

    单例模式属于创建型模式的一种,创建型模式是一类最常用的设计模式,在软件开发中应用非常广泛.创建型模式将对象的创建和使用分离,在使用对象时无需关心对象的创建细节,从而降低系统的耦合度,让设计方案更易于修 ...

  9. java singleton(单例设计模式)

    单例设计模式的主要作用是: 1.控制资源的使用,我们对资源使用线程同步来实现并发访问. 2.节约资源,我们对一个类只进行一个实例化进行全局的资源访问,节约了内存. 3.作为通信媒介,也是数据共享,可以 ...

  10. Java基础 static限定符的使用 以及【 static实现的 singleton(单例)设计模式】

    static实现的 singleton(单例)设计模式 /** static实现的 singleton设计模式 , 使得一个类只能够创建一个static对象 */ 模板设计结构: package Co ...

随机推荐

  1. .NET的两种部署模式,了解一下

    前言 以往部署程序一直是习惯性先安装运行时环境,然后再将发布打包好的程序运行起来:但当多个程序依赖不同版本框架平台时,如果部署在同一台机器上,那就需要在同一台机器上安装多个版本的运行时,总感觉有点不太 ...

  2. selenium+python自动化-元素定位

    自动化只要掌握四步操作:获取元素,操作元素,获取返回结果,断言(返回结果与期望结果是否一致),最后自动出测试报告. 本篇主要讲几种基本的元素定位方法元素定位在这四个环节中是至关重要的,如果说按学习精力 ...

  3. tensorflow core 核心目标依赖图

    Tensorflow的核心代码在core模块中,56w行的代码量让人望而生畏,熟悉了bazel工具之后,发现BUILD文件是理清代码结构的很好的资源,但使用bazel query语法提取出来//ten ...

  4. LGP2233题解

    题目大意 求环上走 \(n\) 步从指定点到达另一指定点,到达指定点后 不得继续移动. 大家都做过P1057传球游戏吧?还记得这道题的思路吗? 设 \(dp[i][j]\) 表示传 \(i\) 次求传 ...

  5. LGP4841题解

    无向联通图计数板子 首先,这个太难了,先让我们来求一个简单的: 无向图计数. 一共 \(\frac {n \times (n+1)} 2\) 条可能存在的边,枚举一条边是否存在,就有 \(2^{\fr ...

  6. 用注册表清除Office Word文档杀手病毒

    不久前,笔者打开word文件时遇到了一件离奇的怪事,常用的Word文件怎么也打不开,总是出现提示框:"版本冲突:无法打开高版本的word文档".再仔细查看,文件夹里竟然有两个名字一 ...

  7. CSI 工作原理与JuiceFS CSI Driver 的架构设计详解

    容器存储接口(Container Storage Interface)简称 CSI,CSI 建立了行业标准接口的规范,借助 CSI 容器编排系统(CO)可以将任意存储系统暴露给自己的容器工作负载.Ju ...

  8. ssh编译安装后重启失败问题

    编译好的ssh重启出现如下报错 这个原因是因为systemd与ssh不兼容造成的 删掉服务 rm /usr/lib/systemd/system/sshd.service 重启 /etc/init.d ...

  9. 6月19日 python学习总结 Django之路由系统

    Django之路由系统   Django的路由系统 Django 1.11版本 URLConf官方文档 URL配置(URLconf)就像Django 所支撑网站的目录.它的本质是URL与要为该URL调 ...

  10. Java中对文件的处理01-递归删除

    package com.ricoh.rapp.ezcx.admintoolweb.util; import java.io.BufferedInputStream; import java.io.Bu ...