Question

我有一个Map Reduce程序，在Reducer类中，我的方法在第一次迭代中没有被调用。我想要实现的是在迭代器中每2个连续值之间生成一些新行。（如：（1,2），（2,3），（3,4）......）。我错过了什么？而且我还测试了我有我想要的对，它看起来很好，但似乎我的方法没有被调用第一对.. generate（） - 将在每2个连续行之间生成新行（填充时间间隔）

input: X, Y, 00:00:00, 908 X, Y, 00:00:05, 122 X, Y, 00:00:07, 123

desired output: X, Y, 00:00:00, 908 X, Y, 00:00:01, 908 X, Y, 00:00:02, 908 X, Y, 00:00:03, 908 X, Y, 00:00:04, 908 X, Y, 00:00:05, 122 X, Y, 00:00:06, 122 X, Y, 00:00:07, 123

Iterator<MyType> iterator = values.iterator();
if (!iterator.hasNext()) return;
first = iterator.next();
while (iterator.hasNext()) {
   nr++;
   first.setStatus(nr);
   context.write(nullWritable, first);
   second = iterator.next();
   List<MyType> newValues = generate(first, second, context);
   for (MyType mt : newValues) {
          mt.setStatus(nr);
          context.write(nullWritable, mt);
    }
   second.setStatus(nr);
   context.write(nullWritable, second);
   first = new InterpolationModelWritable();
   first.setX(second.getX());
   first.setY(second.getY());
   first.setZ(second.getZ());
   first.setTag(second.getTag());

 }

actual result: X, Y, 00:00:00, 908 X, Y, 00:00:05, 122 X, Y, 00:00:06, 122 X, Y, 00:00:07, 123

Answer 1

您的代码存在的问题是您正在陷入hadoop对象重用陷阱。要记住的重要一点是，每次调用next()时，reduce中的值迭代器都不会返回一个新对象，它会重用相同的对象。

现在我们知道我们可以看看你的代码并弄清楚什么是错误的。使用您的逻辑（但作为一个最小的工作示例），我们可以看到通常它可以工作。

@Test
public void noResuseIteratorTest() {

    List<String> values = new ArrayList<>();
    values.add("a");
    values.add("b");
    values.add("c");
    values.add("d");

    String first;
    String second;

    Iterator<String> iterator = values.iterator();
    if (!iterator.hasNext()) return;
    first = iterator.next();
    while (iterator.hasNext()) {
        second = iterator.next();
        System.out.println("Out: " + first + " - " + second);
        first = second;
    }
}

出：a - b
  出：b - c
  出：c - d

但是，在hadoop reduce方法中，返回的值是同一个对象。该测试证明了这个问题：

@Test
public void reuseIteratorTest() {

    class MyList implements Iterable<Text> {

        private List<String> myList = new ArrayList<>();
        private Text reused = new Text();

        public MyList() {
            myList.add("a");
            myList.add("b");
            myList.add("c");
            myList.add("d");
        }

        @Override
        public Iterator<Text> iterator() {
            return new Iterator<Text> () {

                private final Iterator<String> iter = myList.iterator();

                @Override
                public boolean hasNext() {
                    return iter.hasNext();
                }

                @Override
                public Text next() {
                    // We reuse the Text object here!
                    reused.set(iter.next());
                    return reused;
                }

                @Override
                public void remove() {
                    throw new UnsupportedOperationException("");
                }
            };
        }
    }

    MyList myList = new MyList();
    Text first;
    Text second;

    Iterator<Text> iterator = myList.iterator();
    if (!iterator.hasNext()) return;
    first = iterator.next();
    while (iterator.hasNext()) {
        second = iterator.next();
        System.out.println("Out: " + first + " - " + second);
        first = new Text();
        first.set(second);
    }
}

出：b - b
  出：b - c
  出：c - d

所以，简单地做second = iterator.next();并不够好。在第一次迭代中，first和second都指向同一个对象。

要解决此问题，您需要将迭代器值的内容复制到对象中，而不仅仅是指向同一个对象。以Text对象为例，固定版本如下：

@Test
public void reuseFixedIteratorTest() {

    // MyList class from above goes here

    MyList myList = new MyList();
    Text first = new Text();
    Text second = new Text();

    Iterator<Text> iterator = myList.iterator();
    if (!iterator.hasNext()) return;
    first.set(iterator.next());
    while (iterator.hasNext()) {
        second.set(iterator.next());
        System.out.println("Out: " + first + " - " + second);
        first.set(second);
    }
}

出：a - b
  出：b - c
  出：c - d

Hadoop Iterator在第一次迭代时跳过方法调用

1 个答案: