GOF23(1)------单例设计模式

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() {

}

}

如何选用?

单例对象占用资源少,不需要延迟加载:

    枚举式好于饿汉式

单例对象占用资源大,需要延迟加载:
    静态内部类式好于懒汉式


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值