Question

我有一个很大的项目需要完成，而且我遇到了一些死胡同。我想看看这里的社区是否有任何建议。

我有一个大型数据集，我正在尝试构建社交图。该数据包含超过950万个坐标到Short值的映射。对于ConcurrentHashMap中的键值，我使用的是一个String，它是与中间的'，'连接的坐标。

基本上，我找到了用户之间共同的群组数量。我有一个很容易构建的初始hashmap，它将GroupID映射到AvatarID的Vector。这部分运行正常。然后，我有12个线程负责他们自己的GroupID和处理集（在每个groupID中的用户之间添加+ 1），所有访问都是从ConcurrentHashMap完成的。

处理了大约8000个组后，会出现访问问题。一次只有一个线程似乎有效，我不确定这是因为大尺寸还是其他因素。这是一个问题，因为我有300,000个需要处理的组（并且及时）。

关于我如何实现这个以及我可以使用的任何快捷方式，是否有任何建议？我相信读取和写入同样重要，因为如果值存在（如果不创建它），我必须读取坐标，然后在值中添加一个并写回。

我愿意根据需要提供代码，我只是不知道哪些部分与讨论有关。

谢谢你的时间， -mojavestorm

进一步解释：

两个实现及其限制：

1）我有一个HashMap（整数，矢量（整数））preMap，它包含一个GroupID作为键和一个UserIDs的Vector。线程在彼此之间拆分GroupID并使用返回的每个Vector（整数），每个线程根据坐标（将UserID x和UserID y属于（short）n组一起存储）存储到TLongShortHashMap threadMap中的短值，并且每个线程拥有自己的threadMap。坐标映射到长值。完成每个线程后，每个threadMaps中相应键的值被添加到组合Map中的相同键中，这将显示UserID x和UserID y在整个系统中共有多少组。

此实现的问题在于线程之间存在高重叠，因此会创建过多的短值。例如，用户1和用户2一起属于各种组。线程A和线程B负责它们自己的组范围，包括用户1和用户2所属的组，因此线程A和线程B都在其线程映射的副本中存储一个长坐标值（1,2）和一个短的价值。如果发生过度重叠，则内存要求可能非常突出。在我的例子中，我分配给Java的所有46GB ram都用完了，而且很快就用完了。

2）在此实现中使用相同的preMap，每个线程都有一系列他们负责的用户坐标。每个线程运行，并获取它拥有的每个坐标并遍历preMap，检查每个groupID并查看UserID x和UserID y是否属于从preMap返回的向量。此实现消除了threadMaps之间发生的重叠。

问题在于时间。目前，该计划以1400年的惊人速度运行完成。使用的内存大约4GB到15GB，但似乎保持“低”。不完全确定它会保持在极限范围内，但是，我想它会。我没有明显的改进。

希望这些描述很清楚，有助于深入了解我的问题。感谢。

Answer 1

我希望每个线程都处理自己的Map。这意味着每个线程可以相互依赖地工作。线程完成后，您可以组合所有结果。（或者可能在结果完成时将结果组合起来，但这可能会增加复杂性而没有太大的优势）

如果你使用的是短片，我会在TObjectIntHashMap之类的集合中使用，这对于处理原语更有效。

在简单的情况下，您有short个坐标 public static void main（String ... args）throws IOException { int length = 10 * 1000 * 1000; int [] x = new int [length]; int [] y = new int [length];

  Random rand = new Random();
  for (int i = 0; i < length; i++) {
    x[i] = rand.nextInt(10000) - rand.nextInt(10000);
    y[i] = rand.nextInt(10000) - rand.nextInt(10000);
  }

  countPointsWithLongIntMap(x, y);
  countPointsWithMap(x, y);

}

private static Map<String, Short> countPointsWithMap(int[] x, int[] y) {
  long start = System.nanoTime();
  Map<String, Short> counts = new LinkedHashMap<String, Short>();
  for (int i = 0; i < x.length; i++) {
    String key = x[i] + "," + y[i];
    Short s = counts.get(key);
    if (s == null)
      counts.put(key, (short) 1);
    else
      counts.put(key, (short) (s + 1));
  }
  long time = System.nanoTime() - start;
  System.out.printf("Took %.3f seconds to use Map<String, Short>%n", time/1e9);

  return counts;
}

private static TIntIntHashMap countPointsWithLongIntMap(int[] x, int[] y) {
  long start = System.nanoTime();
  TIntIntHashMap counts = new TIntIntHashMap();
  for (int i = 0; i < x.length; i++) {
    int key =  (x[i] << 16) | (y[i] & 0xFFFF);
    counts.adjustOrPutValue(key, 1, 1);
  }
  long time = System.nanoTime() - start;
  System.out.printf("Took %.3f seconds to use TIntIntHashMap%n", time/1e9);
  return counts;
}

打印

Took 1.592 seconds to use TIntIntHashMap
Took 4.889 seconds to use Map<String, Short>

如果您有双坐标，则需要使用双层地图。

public static void main(String... args) throws IOException {
  int length = 10 * 1000 * 1000;
  double[] x = new double[length];
  double[] y = new double[length];

  Random rand = new Random();
  for (int i = 0; i < length; i++) {
    x[i] = (rand.nextInt(10000) - rand.nextInt(10000)) / 1e4;
    y[i] = (rand.nextInt(10000) - rand.nextInt(10000)) / 1e4;
  }

  countPointsWithLongIntMap(x, y);
  countPointsWithMap(x, y);

}

private static Map<String, Short> countPointsWithMap(double[] x, double[] y) {
  long start = System.nanoTime();
  Map<String, Short> counts = new LinkedHashMap<String, Short>();
  for (int i = 0; i < x.length; i++) {
    String key = x[i] + "," + y[i];
    Short s = counts.get(key);
    if (s == null)
      counts.put(key, (short) 1);
    else
      counts.put(key, (short) (s + 1));
  }
  long time = System.nanoTime() - start;
  System.out.printf("Took %.3f seconds to use Map<String, Short>%n", time / 1e9);

  return counts;
}

private static TDoubleObjectHashMap<TDoubleIntHashMap> countPointsWithLongIntMap(double[] x, double[] y) {
  long start = System.nanoTime();
  TDoubleObjectHashMap<TDoubleIntHashMap> counts = new TDoubleObjectHashMap<TDoubleIntHashMap>();
  for (int i = 0; i < x.length; i++) {
    TDoubleIntHashMap map = counts.get(x[i]);
    if (map == null)
      counts.put(x[i], map = new TDoubleIntHashMap());
    map.adjustOrPutValue(y[i], 1, 1);
  }
  long time = System.nanoTime() - start;
  System.out.printf("Took %.3f seconds to use TDoubleObjectHashMap<TDoubleIntHashMap>%n", time / 1e9);
  return counts;
}

打印

Took 3.023 seconds to use TDoubleObjectHashMap<TDoubleIntHashMap>
Took 7.970 seconds to use Map<String, Short>

ConcurrentHashMap的实现和限制

1 个答案: