还在重复创建对象?快试试通过享元模式减少对象创建

开发 前端
在实现享元模式时,通常会创建一个工厂类来管理共享的对象实例,并在需要时返回已存在的实例,而不是创建新的实例。这样可以减少内存占用,并且可以提高系统的性能。

享元模式

享元模式是一种结构型设计模式,旨在通过共享尽可能多的数据来最小化内存使用和提高性能。在享元模式中,对象被分为内部状态和外部状态。内部状态是可以共享的,而外部状态是根据对象的上下文而变化的。

在实现享元模式时,通常会创建一个工厂类来管理共享的对象实例,并在需要时返回已存在的实例,而不是创建新的实例。这样可以减少内存占用,并且可以提高系统的性能。

应用场景

享元模式适用于需要共享大量对象、减少内存占用、优化性能的场景。

  1. 对象的数量非常大,且占用大量内存。通过享元模式可以共享对象,减少内存占用。
  2. 对象的大部分状态可以外部状态,而少部分状态可以内部状态。通过享元模式可以将内部状态和外部状态分离,减少对象数量。
  3. 对象的状态可以被多个对象共享。通过享元模式可以将状态共享,减少重复创建对象。
  4. 对象的创建和销毁频繁,需要优化性能。通过享元模式可以减少对象的创建和销毁,提高性能。

场景示例

过年回家买火车票是一件很困难的事,无数人用刷票软件向服务端发出请求,对于每一个请求服务器都必须做出应答。在用户设置好出发地和目的地之后,每次请求都返回一个查询的车票结果。为了便于理解,我们假设每次返回的只有一趟列车的车票。那么当数以万计的人不问断在请求数据时,如果每次都重新创建一个查询的车票结果,那么必然会造成大量重复对象的创建、销毁,使得 GC 任务繁重、内存占用率高居不下。而这类问题通过享元模式就能够得到很好地改善,从城市 A 到城市 B 的车辆是有限的,车上的铺位也就是硬卧、硬卧、坐票 3 种。我们将这些可以公用的对象缓存起来,在用户查询时优先使用缓存,如果没有缓存则重新创建。这样就将成千上万的对象变为了可选择的有限数量。

首先我们创建一个 Ticket 接口,该接口定义展示车票信息的函数:

public interface Ticket {
    public void showTicketInfo(String bunk);
}

它的一个具体的实现类是 TrainTicket 类:

class TrainTicket implements Ticket {
    public String from; // 始发地
    public String to; // 目的地
    public String bunk; // 铺位
    public int price;

    TrainTicket(String from, String to) {
        this.from = from;
        this.to = to;
    }

    @Override
    public void showTicketInfo(String bunk) {
        price = new Random().nextInt(300);
        System.out.println("购买 从 " + from + " 到 " + to + "的 "
                + bunk + " 火车票" + ", 价格 : " + price);
    }
}

数据库中表示火车票的信息有出发地、目的地、铺位、价格等字段,在购票用户每次查询时如果没有用某种缓存模式,那么返回车票数据的接口实现如下:

public class TicketFactory {

    public static Ticket getTicket(String from, String to) {
        return new TrainTicket(from, to);
    }
}

在 TicketFactory 的 getTicket 函数中每次会 new 一个 TrainTicket 对象,也就是说如果在短时间内有 10000 万用户求购北京到杭州的车票,那么北京到杭州的车票对象就会被创建 10000 次,当数据返回之后这些对象变得无用了又会被虛拟机回收。此时就会造成大量的重复对象存在内存中,GC 对这些对象的回收也会非常消耗资源。如果用户的请求量很大可能导致系统变得极其缓慢,甚至可能导致 OOM。正如上文所说,享元模式通过消息池的形式有效地减少了重复对象的存在。它通过内部状态标识某个种类的对象,外部程序根据这个不会变化的内部状态从消息池中取出对象。使得同一类对象可以被复用,避免大量重复对象。

使用享元模式很简单,只需要简单地改造一下 TicketFactory,具体代码如下:

/**
 * 车票工厂,以出发地和目的地为key缓存车票
 * 
 */
public class TicketFactory {

    static Map<String, Ticket> sTicketMap = new ConcurrentHashMap<String, Ticket>();

    public static Ticket getTicket(String from, String to) {
        String key = from + "-" + to;
        if (sTicketMap.containsKey(key)) {
            System.out.println("使用缓存 ==> " + key);
            return sTicketMap.get(key);
        } else {
            System.out.println("创建对象 ==> " + key);
            Ticket ticket = new TrainTicket(from, to);
            sTicketMap.put(key, ticket);
            return ticket;
        }
    }
}

在 TicketFactory 中添加了一个 map 容器,并且以出发地 + "-" + 日的地为键、以车票对象作为值存储车票对象。这个 map 的键就是我们说的内部状态,在这里就是出发地、横杠、目的地拼接起来的字符串,如果没有缓存则创建一个对象,并且将这个对象缓存到 map 中,下次再有这类请求时则直接从缓存中获取。这样即使有 10000 个请求北京到杭州的车票信息,那么出发地是北京、目的地是杭州的车票对象只有一个。这样就从这个对象从 10000 减到了 1 个,避免了大量的内存占用及频繁的 GC 操作。简单实现代码如下:

public class Test {
    public static void main(String[] args) {
         Ticket ticket01 = TicketFactory.getTicket("北京", "杭州");
         ticket01.showTicketInfo("上铺");
         Ticket ticket02 = TicketFactory.getTicket("北京", "杭州");
         ticket02.showTicketInfo("下铺");
         Ticket ticket03 = TicketFactory.getTicket("北京", "杭州");
         ticket03.showTicketInfo("坐票");
    }
}

运行输出:

创建对象二=>北京-杭州
购买从北京到杭州的上铺火车票,价格:28

使用缓存==>北京-杭州
购买从北京到杭州的下铺火车票,价格:188

使用缓存==>北京-杭州
购买从北京到杭州的坐票火车票,价格:148

从输出结果可以看到,只有第一次查询车票时创建了一次对象,后续的查询都使用的是消息池中的对象。这其实就是相当于一个对象缓存,避免了对象的重复创建与回收。在这个例子中,内部状态就是出发地和目的地,内部状态不会发生变化;外部状态就是铺位和价格,价格会随着铺位的变化而变化。

在 JDK 中 String 也是类似消息池,我们知道在 Java 中 String 是存在于常量池中。也就是说一个 String 被定义之后它就被缓存到了常量池中,当其他地方要使用同样的字符串时,则直接使用的是缓存,而不会重复创建。例如下面这段代码。

public class Test {

    public static void main(String[] args) {
        testString();
    }

    private static void testString() {
        String str1 = new String("abc");
        String str2 = "abc";
        String str3 = new String("abc");
        String str4 = "ab" + "c";
        // 使用equals只判定字符值
        System.out.println(str1.equals(str2));
        System.out.println(str1.equals(str3));
        System.out.println(str3.equals(str2));

        // 等号判等,判定两个对象是不是同一个地址
        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str3 == str2);
        System.out.println(str4 == str2);
    }
}

输出:

true
true
true
false
false
false
true


责任编辑:武晓燕 来源: 沐雨花飞蝶
相关推荐

2017-02-06 09:20:23

JavaScript实践

2016-06-20 11:32:27

JS原型class

2011-04-15 17:07:13

Java

2010-06-24 09:38:42

Windows备份云平台

2009-08-10 13:40:46

创建C# COM对象

2020-05-25 10:20:19

享元模式场景

2012-01-13 12:57:48

Java

2021-03-08 08:40:25

Spring Bean 创建单例对象

2023-02-27 08:09:42

SpringAOP代理

2024-02-27 11:59:12

享元模式对象

2009-12-21 17:35:24

ADO.NET对象

2011-04-11 09:39:55

对象实例

2009-08-10 13:34:11

创建C# COM对象

2021-03-11 08:10:48

JVM对象的创建School

2009-08-25 17:28:23

C#创建DataSet

2024-03-26 10:30:37

Mybatis扩展库API

2009-05-19 14:13:46

.NET反射Assembly

2021-03-17 07:49:21

Java对象内存

2010-10-08 10:52:36

JavaScript对

2010-10-08 11:29:24

JavaScript对象
点赞
收藏

51CTO技术栈公众号