java实现23种设计模式之单例模式
单例模式就是全局对象只有一个，比如开发中spring中常常使用到的bean;
跟静态类有点类似，但是静态类局限很多，不能被继承等。
单例模式又分为饿汉模式和懒汉模式。
饿汉模式是在加载类的时候就创建了实例，不管这个实例能不能用的到；
懒汉模式则是延时加载，用到的时候再创建实例。但是线程不安全。
饿汉模式：
package com.ceshi; public class Singleton { //1.将构造方法私有化，不允许外部直接创建对象 private Singleton(){ } //2.创建类的唯一实例，使用private static修饰 private static Singleton instance=new Singleton(); //3.提供一个用于获取实例的方法，使用public static修饰 public static Singleton getInstance(){ return instance; } public Integer getNum() { return num; } public void setNum(Integer num) { this.num = num; } private Integer num=0; }
package com.ceshi; public class Test { public static void main(String[] args) { //饿汉模式 Singleton s1=Singleton.getInstance(); s1.setNum(2); Singleton s2=Singleton.getInstance(); System.out.println(s2.getNum()); if(s1==s2){ System.out.println("s1和s2是同一个实例"); }else{ System.out.println("s1和s2不是同一个实例"); } } }
输出的是同一个实例，且num为2,所有属性被共用。
懒汉模式：
package com.ceshi; /* * 懒汉模式 * 区别：饿汉模式的特点是加载类时比较慢，但运行时获取对象的速度比较快，线程安全 * 懒汉模式的特点是加载类时比较快，但运行时获取对象的速度比较慢，线程不安全 */ public class Singleton2 { //1.将构造方式私有化，不允许外边直接创建对象 private Singleton2(){ } //2.声明类的唯一实例，使用private static修饰 private static Singleton2 instance; //3.提供一个用于获取实例的方法，使用public static修饰 public static Singleton2 getInstance(){ if(instance==null){ instance=new Singleton2(); } return instance; } }
package com.ceshi; public class Test { public static void main(String[] args) { //懒汉模式 Singleton2 s3=Singleton2.getInstance(); Singleton2 s4=Singleton2.getInstance(); if(s3==s4){ System.out.println("s3和s4是同一个实例"); }else{ System.out.println("S3和s4不是同一个实例"); } } }
结果是同一个实例。
测试线程问题，防止电脑性能好，加一点东西
package com.ceshi; /* * 懒汉模式 * 区别：饿汉模式的特点是加载类时比较慢，但运行时获取对象的速度比较快，线程安全 * 懒汉模式的特点是加载类时比较快，但运行时获取对象的速度比较慢，线程不安全 */ public class Singleton2 { //1.将构造方式私有化，不允许外边直接创建对象 private Singleton2(){ } //2.声明类的唯一实例，使用private static修饰 private static Singleton2 instance; //3.提供一个用于获取实例的方法，使用public static修饰 public static Singleton2 getInstance(){ if(instance==null){ try { // 模拟在创建对象之前做一些准备工作 Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } instance=new Singleton2(); } return instance; } }
package com.ceshi; public class Test { public static void main(String[] args) { //懒汉模式 Thread2[] threads = new Thread2[10]; /*for (Thread2 thread2 : threads) { thread2 = new Thread2(); thread2.start(); }*/ for (int i = 0; i < threads.length; i++) { threads[i] = new Thread2(); threads[i].start(); } } } //测试线程 class Thread2 extends Thread { @Override public void run() { System.out.println(Singleton2.getInstance().hashCode()); } }
测试结果显示
完全不一样
如何解决？首先会想到对getInstance方法加synchronized关键字
public static synchronized Singleton2 getInstance(){ if(instance==null){ try { // 模拟在创建对象之前做一些准备工作 Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } instance=new Singleton2(); } return instance; }
结果又变得一样了。
这样的用法，在性能上会有所下降，因为每次调用getInstance()，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了，需要进行改进。
package com.ceshi; /* * 懒汉模式 * 区别：饿汉模式的特点是加载类时比较慢，但运行时获取对象的速度比较快，线程安全 * 懒汉模式的特点是加载类时比较快，但运行时获取对象的速度比较慢，线程不安全 */ public class Singleton2 { //1.将构造方式私有化，不允许外边直接创建对象 private Singleton2(){ } //2.声明类的唯一实例，使用private static修饰 private static Singleton2 instance; private static synchronized void syncInit() { if (instance == null) { instance = new Singleton2(); } } public static Singleton2 getInstance() { if (instance == null) { syncInit(); } return instance; } }
这样就只创建了一次实例
除非使用枚举类型的单例模式，否则其他模式都可以通过反射机制调用私有的构造方法。
package com.ceshi; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; /** * 单例模式被java反射攻击 * @author Administrator * */ public class SingletonReflectAttack { public static void attack() throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException { Class<?> classType = Singleton2.class; Constructor<?> constructor = classType.getDeclaredConstructor(null); constructor.setAccessible(true); Singleton2 singleton = (Singleton2) constructor.newInstance(); Singleton2 singleton2 = Singleton2.getInstance(); System.out.println(singleton == singleton2); //false } }
package com.ceshi; import java.lang.reflect.InvocationTargetException; public class SingletonReflectAttackMain { public static void main(String[] args) throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException { System.out.println("-------------单例模式被java反射攻击测试--------------"); SingletonReflectAttack.attack(); System.out.println("--------------------------------------------------"); } }
结果：
返回结果为false，说明创建了两个不同的实例。通过反射获取构造函数，然后调用setAccessible(true)就可以调用私有的构造函数；所以创建出来的两个实例时不同的对象。
如果要抵御这种攻击，就要修改构造器，让他在被要求创建第二个实例的时候抛出异常。
package com.ceshi; /* * 懒汉模式 * 区别：饿汉模式的特点是加载类时比较慢，但运行时获取对象的速度比较快，线程安全 * 懒汉模式的特点是加载类时比较快，但运行时获取对象的速度比较慢，线程不安全 */ public class Singleton2 { //1.将构造方式私有化，不允许外边直接创建对象 private Singleton2(){ synchronized (Singleton2.class) { if(false == flag) { flag = !flag; } else { throw new RuntimeException("单例模式正在被攻击"); } } } //2.声明类的唯一实例，使用private static修饰 private static Singleton2 instance; private static boolean flag = false; private static synchronized void syncInit() { if (instance == null) { instance = new Singleton2(); } } public static Singleton2 getInstance() { if (instance == null) { // syncInit(); synchronized (Singleton2.class) { if (instance == null) { //双重校验 instance = new Singleton2(); } } } return instance; } }
在私有的构造方法中再设置同步锁：
抛出异常，如果需要防止此类事件发生，可以通过捕获异常解决问题。
