18

在我的一个应用程序中，我正在使用以下内容：

public void calculate (String className)
{
  ... 
  Class clazz = Class.forName(className);
  ...
}

这个函数被调用几次/秒。大约有 10 个可能的类名。虽然我确实意识到这个函数内部有一些内部缓存，但我认为这种缓存仅在本机级别可用。

出于这个原因，我开始怀疑是否应该添加自己的缓存。

private static Map<String,Class> classMap;

public void calculate (String className)
{
  ... 
  Class clazz = classMap.get(className);
  if (clazz == null) 
  {
      clazz = Class.forName(className);
      if (classMap == null) classMap = new HashMap<String, Class>(40);
      classMap.put(className, clazz);
  }
  ...
}

这会是性能提升还是真的没有区别？

先感谢您

4

4 回答 4

15

我写了一个小脚本来计算这两个函数的执行时间。

这是我使用的 Main 类。

public class Benchmark
{
  public static void main(String... pArgs)
  {
    // prepare all data as much as possible.
    // we don't want to do this while the clock is running.
    Class[] classes = {Object.class, Integer.class, String.class, Short.class, Long.class, Double.class,
                       Float.class, Boolean.class, Character.class, Byte.class};
    int cycles = 1000000;
    String[] classNames = new String[cycles];
    for (int i = 0; i < cycles; i++) 
    {
      classNames[i] = classes[i % classes.length].getName();
    }

    // THERE ARE 2 IMPLEMENTATIONS - CLASSIC vs CACHING
    Implementation impl = new Caching();   // or Classic();

    // Start the clocks !
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < cycles; i++)
    {
      impl.doStuff(classNames[i]);
    }
    long endTime = System.currentTimeMillis();

    // calculate and display result
    long totalTime = endTime - startTime;
    System.out.println(totalTime);
  }
}

这是使用的经典实现Class.forName

  private interface Implementation
  {
    Class doStuff(String clzName);
  }

  private static class Classic implements Implementation
  {
    @Override
    public Class doStuff(String clzName)
    {
      try
      {
        return Class.forName(clzName);
      }
      catch (Exception e)
      {
        return null;
      }
    }
  }

这是使用 aHashMap缓存Class对象的第二个实现。

  private static class Caching implements Implementation
  {
    private Map<String, Class> cache = new HashMap<String, Class>();

    @Override
    public Class doStuff(String clzName)
    {
      Class clz = cache.get(clzName);
      if (clz != null) return clz;
      try
      {
        clz = Class.forName(clzName);
        cache.put(clzName, clz);
      }
      catch (Exception e)
      {
      }
      return clz;
    }
  }

结果：

  • 1100 毫秒无缓存。
  • 缓存只有 15 毫秒。

结论：

  • 这是一个显着的区别 - >是的！
  • 这对我的应用程序是否重要-> 一点也不重要。
于 2013-08-14T18:10:23.033 回答
13

这会是性能提升还是真的没有区别？

如果它产生显着差异，我会感到惊讶 - 如果你只称它为“每秒几次”（而不是说，一百万次），它真的不值得优化。

在进行这种更复杂的设计之前，您至少应该在基准测试中单独尝试一下。我强烈希望Class.forName无论如何都要缓存它，并且在您的应用程序中增加更多复杂性并没有好处。

于 2013-08-14T12:41:57.913 回答
6

Class.forName()做两件事：

  1. 它从类加载器中获取加载的类
  2. 如果没有找到这样的类，它会尝试加载它。

第 1 部分非常快。#2 是真正的工作开始的地方（JVM 可能会碰到硬盘甚至网络，具体取决于类加载器）。如果你传入相同的参数，那么除了第一次调用之外的所有调用都将永远不会到达步骤#2。

所以不：它可能不值得优化。

于 2013-08-14T12:45:26.370 回答
2

不，你不应该。Class.forName 不会两次加载同一个类，而是会尝试在加载的类中查找该类。它是在本机级别完成的，应该非常有效。

于 2013-08-14T12:44:42.307 回答