GOF23(1)------单例设计模式
1.为什么要使用单例设计模式?
举个加载配置文件的例子:
(1)直接使用Java来读取配置文件的代码
package com.cdut.cn.Singleton;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
* 不使用单例模式举例:读取配置文件
* @author Administrator
*
*/
public class AppConfig {
//存放配置文件中A的值
private String parameterA;
//存放配置文件中B的值
private String parameterB;
//只可以访问参数,不可更改
public String getParameterA() {
return parameterA;
}
public String getParameterB() {
return parameterB;
}
//构造方法
public AppConfig() {
//调用读取配置文件的方法
readConfig();
}
/**
* 读取配置文件,把配置文件中的内容读出来设置到属性上
*/
private void readConfig() {
Properties p = new Properties();
InputStream in =null;
try {
in=AppConfig.class.getResourceAsStream("AppConfig.properties");
p.load(in);
//把配置文件中的内容读出来设置到属性上
this.parameterA=p.getProperty("paramA");
this.parameterB=p.getProperty("paramB");
} catch (IOException e) {
System.out.println("装载配置文件出错!");
e.printStackTrace();
}finally {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
(2)应用的配置文件:名字是:AppConfig.properties
paramA=a
paramB=b
(3)写个客户端测试
package com.cdut.cn.Singleton;
/*
* @author Administrator
*
*/
public class Client {
public static void main(String[] args) {
//创建读取应用配置的对象
AppConfig config = new AppConfig();
String paramA = config.getParameterA();
String paramB = config.getParameterB();
System.out.println("paramA="+paramA+",paramB="+paramB);
}
}
* 出现的问题:
通过new一个Appconfig的实例来得到一个操作配置文件内容的对象,若在系统运行中,
若有很多地方都需要使用配置文件的内容,则需要在很多地方创建Appconfig对象,这样会严重浪费系统资源
事实上,在运行期间只需要一个实例对象即可 。
2.使用单例模式来解决
定义:保证一个类仅有一个实例,并提供一个访问它的全局访问点
解决问题的思路: 一个类能被创建多个实例,归根到底在于类的构造器是public型的,所以要想控制一个类只被创建一个实例,则需收回创建实例的权限(改为private),让类自身来负责自己类实例的创建,然后由这个类来提供外部访问这个类实例的方法(getInstance()方法)。
单例模式的优点:
--单例模式只生成一个实例,减少了系统性能开销,当一个对象的产生需要比较多的资源时,如读取配置,产生其他依赖对象时,则可以通过在应用启动时直接产生一个单例对象,然后永久驻留内存的方式来解决。
--单例模式可以在系统设置全局的访问点,优化共享资源访问,例如可以设计一个单例类,负责所有数据表的映射处理。
常用的五种单例模式实现方式:
-主要:
1.懒汉式:(线程安全,调用率高,但是不能延时加载)
2.饿汉式:(线程安全,调用效率不高,但是可以延时加载)
-其他:
1.双重检测锁式(由于JVM底层内部模型原因,偶尔出现问题,不建议使用)
2.静态内部类式(线程安全,调用效率高,可以延时加载)
3.枚举单例(线程安全,调用效率高,不能延时加载)
(1)懒汉式实现
package com.cdut.cn.Singleton;
/**
* 懒汉式:
* 既然懒,创建对象就不着急,会等到要使用对象的时候才创建
* @author Administrator
*
*/
public class LazyLoad {
/**
* 定义一个变量来存储创建好的类实例
*/
private static LazyLoad instance=null;
/**
* 私有化构造方法,可以在内部控制创建实例的数目
*/
private LazyLoad() {
}
/**
* 定义一个方法来为客户端提供类实例
* @return 一个Singleton实例
*/
public static synchronized LazyLoad getInstance() {
if(instance==null) {
//若没有,就创建一个类实例,并把值赋给存储类实例的变量
instance = new LazyLoad();
}
//若有值则直接使用
return instance;
}
/**
* 单例可以有自己的操作
*/
public void singletonOperation() {
//功能处理
}
/**
* 单例可以有自己的属性
*/
private String singletonData;
/**
* 让外部通过这些方法来访问属性的值
* @return 属性的值
*/
public String getSingletonData() {
return singletonData;
}
}
(2)饿汉式
package com.cdut.cn.Singleton;
/**
* 测试懒汉式
* 所谓饿汉式,既然饿,在创建对象实例时就比较急,于是在装载类的时候就创建对象实例
* @author Administrator
*
*/
public class HungryLoad {
/**
* 定义一个变量来存储创建好的类实例,直接创建类实例,只能创建一次
*/
private static HungryLoad instance= new HungryLoad();
//私有化构造器
private HungryLoad() {
}
/**
* 定义一个方法为客户端提供类实例
* @return 一个Singleton的实例
*/
public static HungryLoad getInstance() {
return instance;
}
/**
* 单例可以有自己的操作
*/
public void singletonOperation() {
//功能处理
}
/**
* 单例可以有自己的属性
*/
private String singletonData;
/**
* 让外部通过这些方法来访问属性的值
* @return 属性的值
*/
public String getSingletonData() {
return singletonData;
}
}
注意:不管采用哪种方式,在运行期间,都只会生成一个实例,而访问这些类的一个全局访问点,就是静态的getInstance()方法。
单例模式的优缺点:
1.时间和空间
懒汉式:是典型的时间换空间,每次获取实例都会进行判断,看是否需要创建,浪费判断的时间。若不使用,则不会创建,也就节约了内存空间。
饿汉式:典型的空间换时间,当类装载时就创建了类实例,不管用不用都会创建,每次使用也不需判断,节省运行时间。
1.线程安全
饿汉式:线程安全的,因为虚拟机保证只会装载一次,装载的时候是不会发生并发的。
懒汉式:不加同步的懒汉式是线程不安全的。若两个线程同时调用getInstance()方法,就会导致并发。不过只要加上Synchronized即可实现线程安全,如下:
public static synchronized Singleton getInstance()
不过这样会降低这个访问速度,而且没次都要判断,可以使用“双重检测加锁”方式实现,既能实现线程安全,又能使性能不收太大影响。
双重检测加锁:并不是每次进入getInstance()方法都需要同步,进入方法后先检查实例是否存在,若不存在则进入下面的同步块(这是第一重检查)。进入同步块后,再次检查实例是否存在,若不存在就在同步情况下创建一个实例(这是第二重检查)。这样只需要同步一次,就可减少多次在同步情况下进行判断所浪费的时间。
双重检测加锁的实现会使用一个关键字volatile:被volatile修饰的变量的值不会被本地线程缓存,所有对该变量的读写都是直接操作共享内存,从而确保多个线程能正确处理该变量。但volatile关键字会屏蔽掉虚拟机中一些必要的代码优化,运行效率不高,所以不建议使用(双重检查锁用于Java5及以上版本)
示例:
package com.cdut.cn.Singleton;
public class DoubleCheckAddLock {
/**
* 对保存实例的变量添加volatile修饰
*/
private volatile static DoubleCheckAddLock instance = null;
private DoubleCheckAddLock(){}
public static DoubleCheckAddLock getInstance() {
//检查是否存在
if(instance==null) {
//同步块,线程安全的创建实例
synchronized(DoubleCheckAddLock.class) {
//再次检查是否存在,若不存在才真正的创建
if(instance==null) {
instance =new DoubleCheckAddLock();
}
}
}
return instance;
}
}
在Java中更好的单例实现方式
1.静态内部类:这种方法线程安全,调用效率高,可以延迟加载
public class Singleton {
private static class SingletonInnerClass {private static final Singleton instance = new Singleton();
}
//私有构造方法
private Singleton() {}
public Singleton getInstance() {
return SingletonInnerClass.instance;
}
}
2.枚举实现:
优点:实现简单,枚举本身就是单例模式。由JVM从根本上提供保障!
避免通过反射和反序列化的漏洞
唯一缺点:没有延时加载
public enum Singleton {
//定义一个枚举元素,它就代表了Singleton的一个实例Instance;
//添加需要的操作
public void SingletonOperation() {
}
}
如何选用?
单例对象占用资源少,不需要延迟加载:
枚举式好于饿汉式
单例对象占用资源大,需要延迟加载:
静态内部类式好于懒汉式