软件设计模式—单例模式

前篇——软件设计模式-基础
前篇——软件设计模式-三种工厂模式
前篇——软件设计模式-装饰者模式

单例模式是创建型模式

目录

  • 1.定义及理解
    • 1.1 定义
    • 1.2 特点
    • 1.3 类图
      • 1.3.1结构说明:
  • 2. 单例模式的实现
    • 2.1实现方式分类
      • 2.1.1 懒汉式实现(单例对象延迟加载)
      • 2.1.2 饿汉式实现
      • 2.1.3 懒汉、饿汉对比
  • 3. 例子
    • 3.1 e.g.1(唯一月亮)
      • 3.1.2 单例模式的应用场景
      • 3.1.3 单例模式优点

1.定义及理解

在实践项目开发中经常会遇到一些对象,这样的对象在全局当中仅存在一个就可以。如果出现多个。程序执行可能会失败。或是内存上的管理问题。就是只需要一个即可,比如单位的公章。
记得之前英语学the的用法(用来特指唯一的存在的事物)
the sun、the moon

1.1 定义

定义:单例模式是确保一个类仅有一个实例,并提供一个访问它的全局访问点。

1.2 特点

  1. 单例类只有一个实例对象(不能通过像以往的 new 来创建对象
  2. 该单例对象必须由单例类自行创建
  3. 单例类对外提供一个访问该单例的全局访问点(即有一个对外的方法)

1.3 类图

软件设计模式—单例模式_第1张图片

1.3.1结构说明:

(单例模式的结构中只包含一个角色)

单例类:包含一个实例且能自行创建这个实例的类。

  1. 单例类有一个包含自身声明的类变量private Singleton uniqueInstance;
    用来存储单例对象的一个变量(私有)
    类变量:(static)
  2. 还有一个 getInstance() 静态方法来获得它的实例
  3. 构造方法:单例类的构造方法访问权限是private

2. 单例模式的实现

怎么样保证创建的对象具有唯一性呢:让单例类的构造方法私有化即可

2.1实现方式分类

2.1.1 懒汉式实现(单例对象延迟加载)

懒汉式为啥称懒呢,就是类加载时不生成实例对象,等到第一次调用 getInstance() 方法时才去创建。

public class LazySingleton{
	//保证instance在所有线程中同步
	private static volatile LazySingleton instance = null;
	//私有化构造方法(避免类在外部被实例化)
	private LazySingleton(){}
	//向外提供获取对象的方法
	public static synchronized LazySingleton getInstance(){
	//在静态方法中使用的变量也必须是静态的
		//判断是否有对象
		if(instance == null){
			instance = new LazySingleton();
		}
		return instance;
	}
}

sychronized(同步代码块关键字)
并发编程 sychronized 的使用——来自 淘小笛 的博客
sychronized 解决的是避免多个线程多次执行instance = new LazySingleton();避免创建多个对象生成,违反了单例模式设计初衷。(即假如此时有A、B两个线程,A线程执行完毕后,B线程才可以进行)

2.1.2 饿汉式实现

饿汉式呢,见名知意,就是比较饥渴
单例类只要一加载就创建一个单例,在调用getInstance()方法前就已经存在单例了。

public class HungrySingleton{
//类初始化时,立即加载对象(无延时加载),但是线程安全
	//直接赋值,不多BIBI
	private static final HungrySingleton instance = new HungrySingleton();
	private HungrySingleton(){}
	public static HungrySingleton getInstance(){
		return instance;
	}
}

Q:为什么不用sychronized关键字了:static变量会在装载时初始化。此时不会涉及多个线程对象访问该对象的问题,虚拟机保证只会装载一次该类,肯定不会发生访问的问题。因此可省略synchronized关键字
饿汉式不足:就是你提前创建的对象是必须创建的,即之后会不会用到不确定,用不到就是资源的浪费。

2.1.3 懒汉、饿汉对比

分类 懒汉式实现 饿汉式实现
线程 不安全 安全
调用效率 不高
延时加载 可以 不可以
加载类的速度
加载对象的速度

3. 例子

3.1 e.g.1(唯一月亮)

public class Moon{
	private static Moon uniquemoon = null;
	double radius;
	double distancetoearth;
	private Moon(){
		radius = 1738;
		distancetoearth = 363300;
	}
	public static synchronized Moon getMoon(){
		if(uniquemoon == null){
			uniquemoon = new Moon();
		}
		return uniquemoon;
	}
	public String show(){
		String a = "月亮的半径是"+radius+"距离地球"+distancetoearth;
		return a;
	}
}

public class DemoMoon{
	public static void main(String args[]){
		//静态方法可以通过类名.方法名来调用。通过getMoon()方法来获得对象
		Moon m = Moon.getMoon();
		System.out.println(m.show());
	}
}

3.1.2 单例模式的应用场景

  1. 某个类只要求生成一个对象(如:一个班中的班长、每个人的身份证号)
  2. 当对象需要被共享的场合:由于单例模式只允许创建一个对象,共享该对象可以节省内存,并加快对象的访问速度。(如:Web(JSP中的application))
  3. 当类需要被频繁的实例化,而创建的对象又频繁的被销毁的时候(如:多线程的线程池、网络连接池)

3.1.3 单例模式优点

  1. 减少了系统性能的开销,当一个对象事多(比如读取配置、产生其他依赖对象),则通过应用启动时直接产生一个单例对象,然后永久驻留内存的方式来解决。
  2. 单例模式的唯一实例有单例类本身控制,可以很好的控制用户何时访问它。

你可能感兴趣的:(java)