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

}

}

如何选用？

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

    枚举式好于饿汉式

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