设计模式
设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统都是多赢的;设计模式使代码编制真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样。
1、单例模式
什么是单例模式?
单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。
单例模式分为:懒汉式单例、饿汉式单例
单例模式:一个类只能有一个实例,管理器类/调度器类
实现单例模式的三个关键点
- 构造方法私有化
- 提供一个本类型的静态成员变量
- 提供一个静态的共有方法,返回值类型是本类型
单例模式特点
- 单例类只能有一个实例。
- 单例类必须自己创建自己的唯一实例。
- 单例类必须给所有其他对象提供这一实例。
1.饿汉式单例
- 实例提前就创建好,是线程安全的
- 如果后期没有使用到这个单例模式,就会浪费内存空间
使用场景:如果此单例占用内存比较小,可以使用饿汉式单例进行创建
优点:没有加锁,执行效率会提高。
缺点:类加载时就初始化,浪费内存。
public class HungrySingleton {
private static HungrySingleton instance = new HungrySingleton();
private HungrySingleton(){
}
public static HungrySingleton getInstance(){
return instance;
}
}
2.懒汉式单例
1、懒汉式单例初级版本:
- 这种方式是最基本的实现方式,这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized,所以严格意义上它并不算单例模式。
- 不要求线程安全,在多线程不能正常工作。
public class LazySingleton {
private static LazySingleton instance;
private LazySingleton(){
}
public static LazySingleton getInstance(){
if(instance == null){
instance = new LazySingleton();
}
return instance;
}
}
2、懒汉式单例
- 使用synchronized关键字修饰静态方法,能够在多线程中很好的工作(线程安全),但是,效率很低。
优点:第一次调用才初始化,避免内存浪费。
缺点:必须加锁 synchronized 才能保证单例,但加锁会影响效率
public class LazySingleton {
private static LazySingleton instance;
private LazySingleton(){
}
public synchronized static LazySingleton getInstance(){
if(instance == null){
instance = new LazySingleton();
}
return instance;
}
}
3、双重校验锁(double check)
volatile可以防止指令重排序
如果不使用volatile关键字可能会报错,见代码注释。
- 这种方式采用双锁机制,安全且在多线程情况下能保持高性能。
public class LazySingleton {
// volatile可以防止指令重排序
private volatile static LazySingleton instance;
private LazySingleton() {
}
public static LazySingleton getInstance() {
//双重检测 ,double check
if (instance == null) {
synchronized (LazySingleton.class) {
if (instance == null) {
//JVM 指令重排序; 在单线程不会有数据不一致情况
// 1, new 实例 10S
// 2,给引用赋值 2S
// 3,return 引用 1S 13S
// 231 3S 因为指令重排序的问题,在实际使用过程中会出现对象状态不正确的现象
instance = new LazySingleton();
}
}
}
return instance;
}
}
单例模式的攻破
- 使用反射攻破
- 使用序列化攻破
1、使用反射攻破
代码演示:
public static void test() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class<?> aClass = Class.forName("com.codeyancy.smp.LazySingleton");
//得到无参构造
Constructor<?> constructor = aClass.getDeclaredConstructor();
//把访问权限设为可访问
constructor.setAccessible(true);
Object o1 = constructor.newInstance();
Object o2 = constructor.newInstance();
Object o3 = constructor.newInstance();
System.out.println(o1);
System.out.println(o2);
System.out.println(o3);
System.out.println(o1==o2);
System.out.println(o1==o3);
System.out.println(o2==o3);
}
结果:
与单例模式一个类只能有一个实例不符合!
2、使用序列化攻破
- 首先需要单例模式实现接口:
public class LazySingleton implements Serializable
代码演示:
public static void main(String[] args) {
LazySingleton instance = LazySingleton.getInstance();
try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("obj.txt"));
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("obj.txt"))) {
objectOutputStream.writeObject(instance);
Object object = objectInputStream.readObject();
System.out.println(object);
System.out.println(instance);
System.out.println(object == instance);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
结果:
与单例模式一个类只能有一个实例不符合!
使用枚举类实现单例
在effective java这本书中说道,最佳的单例实现模式就是枚举模式。利用枚举的特性,让JVM来帮我们保证线程安全和单一实例的问题。除此之外,写法还特别简单。
只有一个实例,使用反射或者序列化都不能有其他实例
- 线程安全
- 这种实现方式还没有被广泛采用,但这是实现单例模式的最佳方法。它更简洁,自动支持序列化机制,绝对防止多次实例化。
public enum EnumSingleton {
INSTANCE;
public void doSomething() {
System.out.println("doSomething...");
}
}
调用方法:
public class TestEnumSingleton {
public static void main(String[] args) {
EnumSingleton.INSTANCE.doSomething();
}
}
直接通过EnumSingleton.INSTANCE.doSomething()的方式调用即可。方便、简洁又安全。