一.单例模式作为23种设计模式之一,也属于三大类-创建型设计模式之一,其特点是对该类实例化只有一个对象
在Java应用中,单例对象能保证在一个JVM中,该对象只有一个实例存在。这样的模式有几个好处:
1、某些类创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销。
2、省去了new操作符,降低了系统内存的使用频率,减轻GC压力。
3、有些类如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个的话,系统完全乱了。
单例模式的构建模式大体分为两类:饿汉式,懒汉式;
1.饿汉式
class Singlton{
//私有的构造方法
private Singtlon(){}
private static Singlton singlton = new Singlton();
//提供一个公有方法给外部调用
public static Singlton getSinglton(){
return singlton;
}
}
2.懒汉式
class Singlton{
//私有的构造方法
private Singtlon(){}
private static Singlton singlton =null;
//提供一个公有方法给外部调用
public static Singlton getSinglton(){
if(singlton==null){
singlton = new Singlton();
}
return singlton;
}
}
一些细节:
1.饿汉式比懒汉式线程安全;
2.关于懒汉式的线程安全的解决方案:
使用线程锁的方式,对于单例模式来说,临界资源是对象singtlon;
所以我们只要给临界资源上锁就可以啦!
public static Singlton getSinglton(){
if(singlton==null){
synchronzied(singlton){
singlton = new Singlton();
}
}
return singlton;
}
3.还可以使用内部类来进行优化,JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的(就是加载完毕后别的线程才能使用)。
这样当我们第一次调用getInstance的时候,JVM能够帮我们保证instance只被创建一次,
并且会保证把赋值给instance的内存初始化完毕,这样我们就不用担心上面的问题。
同时该方法也只会在第一次调用的时候使用互斥机制,这样就解决了低性能问题。
public class Singleton {
/* 私有构造方法,防止被实例化 */
private Singleton() {
}
/* 此处使用一个内部类来维护单例 */
private static class SingletonFactory {
private static Singleton instance = new Singleton();
}
/* 获取实例 */
public static Singleton getInstance() {
return SingletonFactory.instance;
}
/* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */
private Object readResolve() {
return getInstance();
}
}
反射中有一个方法setAccessiable(true)(暴力反射),
在私有构造方法中进行处理
private static boolean flag;
/* 私有构造方法,防止被实例化 */
private Singleton() {
if(!flag){
flag = false;
}else{
throw new RuntimeException("不能多次创建单例对象");
}
}
那么内存中就会出现俩个一样的单例对象,只是内存地址不同。这种情况我们可以使用readResolve方法来防止。
private Object readResolve(){.....}
ObjectInputStream 会检查对象的class是否定义了readResolve方法。
如果定义了,将由readResolve方法指定返回的对象。返回对象的类型一定要是兼容的,否则会抛出ClassCastException 。
例子:
public abstract class Singleton8 implements Serializable{
private static final long serialVersionUID = 7863921642928237696L;
/* 此处使用一个内部类来维护单例 */
private static class SingletonFactory {
@SuppressWarnings("serial")
private static Singleton8 instance = new Singleton8(){};
}
//测试方式,把单例对象序列化后再反序列化从而获得一个新的对象 就相当于复制了一个单例对象
public Singleton8 copy() throws Exception{
ByteArrayOutputStream os = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(Singleton8.getInstance());
InputStream is = new ByteArrayInputStream(os.toByteArray());
ObjectInputStream ois = new ObjectInputStream(is);
Singleton8 obj = (Singleton8) ois.readObject();
return obj;
}
/* 获取实例 */
public static Singleton8 getInstance() {
return SingletonFactory.instance;
}
/* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */
/* 把这个方法注释前和注释后来运行测试代码观察结果 */
private Object readResolve() {
return getInstance();
}
}