九、单例设计模式

最新推荐文章于 2019-04-04 11:33:00 发布

风zi

最新推荐文章于 2019-04-04 11:33:00 发布

阅读量157

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/qq_35241080/article/details/84590644

版权

设计模式专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、介绍

单例模式，是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。

优点：
1.在内存里只有一个实例，减少了内存开销
2.可以避免对资源的多重占用

缺点：
1.没有接口，扩展困难，想扩展只能修改代码。

注意重点：
1.反射调用创建对象。
2.clone方式复制对象
3.私有构造器，final、与volatile的使用
4.延迟加载
5.线程安全
6.序列化反序列化安全

适用场合：
1.需要频繁的进行创建和销毁的对象；
2.创建对象时耗时过多或耗费资源过多，但又经常用到的对象；
3.工具类对象；
4.频繁访问数据库或文件的对象。

二、实现方式

（一）饿汉式实现方式

饿汉式：类加载时就初始化实例

public class Singleton {
  //静态常量方式，final确定其一旦创建不可修改
    private final static Singleton INSTANCE = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

//有静态代码块初始化
public class Singleton {
	private static Singleton instance;
    static {
        instance = new Singleton(); //静态代码块初始化
    }
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。

缺点：

1.在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。
2.无法避免反射调用来创建对象，所以需要对构造器进行调整。
3.无法避免克隆复制对象。

1.反射浮现对象创建

public class Singleton {
	private static Singleton instance;
    static {
        instance = new Singleton(); //静态代码块初始化
    }
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
    //测试
    public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    	Singleton s1 = Singleton.getInstance();
    	Singleton s2 = Singleton.getInstance();
    	//反射创建对象
    	Constructor<Singleton> c = Singleton.class.getDeclaredConstructor();
    	c.setAccessible(true);
    	Singleton s3 = c.newInstance();
    	System.out.println(s1);
    	System.out.println(s2);
    	System.out.println(s3);
      /**s1==s2
com.sjms.singleton.Singleton@6150818a
com.sjms.singleton.Singleton@6150818a
com.sjms.singleton.Singleton@6c68bcef*/
	}
}

避免反射创建对象调整-调整构造器

public class Singleton {
	private static Singleton instance;
    static {
        instance = new Singleton(); //静态代码块初始化
    }
  //如果是懒汉式这里会在对象初始化完成之前，仍然可以用反射来创建对象，避免这种情况去掉if判断即可
    private Singleton() {
    	if(instance != null)
    		throw new RuntimeException("避免反射创建对象");
    }
    public static Singleton getInstance() {
        return instance;
      }
    }

2.克隆实现对象创建

public class Singleton implements Cloneable{
	private static Singleton instance;
    static {
        instance = new Singleton(); //静态代码块初始化
    }
    private Singleton() {
    	if(instance != null)
    		throw new RuntimeException("避免反射创建对象");
    }
    public static Singleton getInstance() {
        return instance;
    }
    
    
    public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, CloneNotSupportedException {
    	Singleton s1 = Singleton.getInstance();
    	Singleton s2 = Singleton.getInstance();

    	Singleton s3 = (Singleton) s1.clone();
    	System.out.println(s1);
    	System.out.println(s2);
    	System.out.println(s3);
    	/**
com.sjms.singleton.Singleton@6c68bcef
com.sjms.singleton.Singleton@6c68bcef
com.sjms.singleton.Singleton@504c2683
    	 */
	}
}

调整clone函数，避免多例情况出现

public class Singleton implements Cloneable{
	private static Singleton instance;
    static {
        instance = new Singleton(); //静态代码块初始化
    }
    private Singleton() {
    	if(instance != null)
    		throw new RuntimeException("避免反射创建对象");
    }
    public static Singleton getInstance() {
        return instance;
    }
  //重写克隆函数，修改返回值
    @Override
    public Object clone(){
    	return getInstance();
    }
    
    public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, CloneNotSupportedException {
    	Singleton s1 = Singleton.getInstance();
    	Singleton s2 = Singleton.getInstance();

    	Singleton s3 = (Singleton) s1.clone();
    	System.out.println(s1);
    	System.out.println(s2);
    	System.out.println(s3);
    	/**
com.sjms.singleton.Singleton@504c2683
com.sjms.singleton.Singleton@504c2683
com.sjms.singleton.Singleton@504c2683
    	 */
	}
}

3.序列化与反序列化问题
我们知道java 对象的序列化操作是实现Serializable接口，我们就可以把它往内存地写再从内存里读出而"组装"成一个跟原来一模一样的对象. 但是当我们遇到单例序列化的时候，就出现问题了。当从内存读出而组装的对象破坏了单例的规则，会创建新的对象

public class Singleton implements Cloneable,Serializable{
	private static Singleton instance;
    static {
        instance = new Singleton(); //静态代码块初始化
    }
    private Singleton() {
    	if(instance != null)
    		throw new RuntimeException("避免反射创建对象");
    }
    public static Singleton getInstance() {
        return instance;
    }
    @Override
    public Object clone(){
    	return getInstance();
    }
    
    public static void main(String[] args) {
    	
    	try {
    		Singleton s1 = Singleton.getInstance();
			FileOutputStream fosRef = new FileOutputStream(new File(
					"myObjectFile.txt"));
			ObjectOutputStream oosRef = new ObjectOutputStream(fosRef);
			oosRef.writeObject(s1);
			oosRef.close();
			fosRef.close();
			System.out.println(s1);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		//
		try {
			FileInputStream fisRef = new FileInputStream(new File(
					"myObjectFile.txt"));
			ObjectInputStream iosRef = new ObjectInputStream(fisRef);
			Singleton s = (Singleton) iosRef.readObject();
			iosRef.close();
			fisRef.close();
			System.out.println(s);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		/**
com.sjms.singleton.Singleton@468864af
com.sjms.singleton.Singleton@6c2fdbb1
		 */
	}
}

序列化反序列化问题解决避免出现多例问题解决

实现了readResolve方法后，jvm就会有readResolve返回指定对象，也就保证了单例性。

public class Singleton implements Cloneable,Serializable{
	private static Singleton instance;
    static {
        instance = new Singleton(); //静态代码块初始化
    }
    private Singleton() {
    	if(instance != null)
    		throw new RuntimeException("避免反射创建对象");
    }
    public static Singleton getInstance() {
        return instance;
    }
    private Object readResolve(){
        return getInstance();
    }
    @Override
    public Object clone(){
    	return getInstance();
    }
    
    public static void main(String[] args) {
    	
    	try {
    		Singleton s1 = Singleton.getInstance();
			FileOutputStream fosRef = new FileOutputStream(new File(
					"myObjectFile.txt"));
			ObjectOutputStream oosRef = new ObjectOutputStream(fosRef);
			oosRef.writeObject(s1);
			oosRef.close();
			fosRef.close();
			System.out.println(s1);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		//
		try {
			FileInputStream fisRef = new FileInputStream(new File(
					"myObjectFile.txt"));
			ObjectInputStream iosRef = new ObjectInputStream(fisRef);
			Singleton s = (Singleton) iosRef.readObject();
			iosRef.close();
			fisRef.close();
			System.out.println(s);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		/**
com.sjms.singleton.Singleton@248a4156
com.sjms.singleton.Singleton@248a4156
		 */
	}
}

注意：克隆、反射与序列化问题在其它创建方式中一样存在，后面的介绍就不在重复；

（二）懒汉式实现方式

懒汉式：在使用时才初始化实例；克隆与反射的问题同样存在不在叙述；

1.简单实现–线程不安全方式，不可用

public class Singleton {
    private static Singleton singleton;
    private Singleton() {}
    public static Singleton getInstance() {
      //线程A进入返现是null准备创建对象时被挂起
      //此时线程B获得使用权进入发现为null创建对象返回
      //此时线程A被唤醒，执行创建对象并返回，此时相当于创建了两个对象
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
  //多线程测试，可自行debug
      public static void main(String[] args) {
//本人测试子线程放在主线从下加载对象则显示不出来两个线程的执行效果，由于我使用的是celipse版本问题吧。 
        new Thread(new Task()).start();
    	Singleton s1 = Singleton.getInstance();
	}
}
//子线程测试
class Task implements Runnable{
	@Override
	public void run() {
		Singleton s2 = Singleton.getInstance();
		System.out.println(s2);
	}
}

2.懒汉式–线程同步方式

public class Singleton {
    private static Singleton singleton;
    private Singleton() {}
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

解决上面实现方式的线程不安全问题，做个线程同步就可以了，于是就对getInstance()方法进行了线程同步。

缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。

3.同步代码块方式–依然存在线程安全

public class Singleton {
    private static Singleton singleton;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
          //依然会出现线程安全问题
            synchronized (Singleton.class) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

（三）双重检查实现方式

public class Singleton {
   //volatile：内存可见性、避免指令重排序
    private static volatile Singleton singleton;
  private Singleton() {
    if(singleton != null){//如果想反射无法创建取消 if判断
      	throw new RuntimeException("避免反射创建对象");
    }
  }
    public static Singleton getInstance() {
        if (singleton == null) {//未实例化时进入
            synchronized (Singleton.class) {
              //再次检查，避免线程安全问题出现
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

volatile：内存可见性、避免指令重排序。

双重检查避免对象实例化后的获取同步加锁问题，当初始化后不会进入同步加锁位置。

优点：线程安全；延迟加载；效率较高。

（四）静态内部类

public class Singleton {

    private Singleton() {}
  
    private static class SingletonInstance {
      //初始化位置放置在静态内部类中
        private static final Singleton INSTANCE = new Singleton();
    }
  
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

优点：静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。

（五）枚举

public enum EnumInstance {
    INSTANCE{
        protected  void printTest(){
            System.out.println("Geely Print Test");
        }
    };
    protected abstract void printTest();
    private Object data;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }
    public static EnumInstance getInstance(){
        return INSTANCE;
    }

    public static void main(String[] args) {
        EnumInstance instance = EnumInstance.getInstance();
        instance.printTest();
        instance.setData(11111);
        Object data2 = instance.getData();
        System.out.println(data2);
	}
}

借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。可能是因为枚举在JDK1.5中才添加，所以在实际项目开发中，很少见人这么写过。

优点:系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

缺点:当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new，可能会给其他开发人员造成困扰，特别是看不到源码的时候。

资料来源
单例模式的八种写法比较： https://www.cnblogs.com/zhaoyan001/p/6365064.html
https://blog.csdn.net/qq_27093465/article/details/50978916
https://blog.csdn.net/zhangliangzi/article/details/52438401
序列化问题：https://blog.csdn.net/anLA_/article/details/70194738
还有慕课网geely老师视频与大话设计模式

风zi

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
九、单例设计模式

一、介绍单例模式，是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。适用场合：1.需要频繁的进行创建和销毁的对象；2.创建对象时耗时过多或耗费资源过多，但又经常用到的对象；3.工具类对象；4.频繁访问数据库或文件的对象。二、实现方式（一）饿汉式实现方式饿汉式：类加载时就初始化实例public class Singleton { //静态常量方式，final...
复制链接

扫一扫