Java RepeatingTestThread类代码示例

import org.apache.hadoop.test.MultithreadedTestUtil.RepeatingTestThread; //导入依赖的package包/类
/**
 * Add a thread which periodically triggers deletion reports,
 * heartbeats, and NN-side block work.
 * @param interval millisecond period on which to run
 */
public void addReplicationTriggerThread(final int interval) {

  testCtx.addThread(new RepeatingTestThread(testCtx) {
    
    @Override
    public void doAnAction() throws Exception {
      for (DataNode dn : cluster.getDataNodes()) {
        DataNodeTestUtils.triggerDeletionReport(dn);
        DataNodeTestUtils.triggerHeartbeat(dn);
      }
      for (int i = 0; i < 2; i++) {
        NameNode nn = cluster.getNameNode(i);
        BlockManagerTestUtil.computeAllPendingWork(
            nn.getNamesystem().getBlockManager());
      }
      Thread.sleep(interval);
    }
  });
}
 

import org.apache.hadoop.test.MultithreadedTestUtil.RepeatingTestThread; //导入依赖的package包/类
@Test
public void testRepeatingThread() throws Exception {
  final AtomicInteger counter = new AtomicInteger();

  TestContext ctx = new TestContext();
  ctx.addThread(new RepeatingTestThread(ctx) {
    @Override
    public void doAnAction() throws Exception {
      counter.incrementAndGet();
    }
  });
  ctx.startThreads();
  long st = Time.now();
  ctx.waitFor(3000);
  ctx.stop();
  long et = Time.now();
  long elapsed = et - st;

  // Test should have waited just about 3 seconds
  assertTrue("Test took " + (et - st) + "ms",
      Math.abs(elapsed - 3000) < 500);
  // Counter should have been incremented lots of times in 3 full seconds
  assertTrue("Counter value = " + counter.get(),
      counter.get() > 1000);
}
 

import org.apache.hadoop.test.MultithreadedTestUtil.RepeatingTestThread; //导入依赖的package包/类
/**
 * Add a thread which periodically triggers failover back and forth between
 * the two namenodes.
 */
public void addFailoverThread(final int msBetweenFailovers) {
  testCtx.addThread(new RepeatingTestThread(testCtx) {
    
    @Override
    public void doAnAction() throws Exception {
      System.err.println("==============================\n" +
          "Failing over from 0->1\n" +
          "==================================");
      cluster.transitionToStandby(0);
      cluster.transitionToActive(1);
      
      Thread.sleep(msBetweenFailovers);
      System.err.println("==============================\n" +
          "Failing over from 1->0\n" +
          "==================================");

      cluster.transitionToStandby(1);
      cluster.transitionToActive(0);
      Thread.sleep(msBetweenFailovers);
    }
  });
}
 

import org.apache.hadoop.test.MultithreadedTestUtil.RepeatingTestThread; //导入依赖的package包/类
/**
 * Add a thread which periodically triggers failover back and forth between the namenodes.
 */
public void addFailoverThread(final int msBetweenFailovers) {
  testCtx.addThread(new RepeatingTestThread(testCtx) {
    @Override
    public void doAnAction() throws Exception {
      // fail over from one namenode to the next, all the way back to the original NN
      for (int i = 0; i < nns; i++) {
        // next node, mod nns so we wrap to the 0th NN on the last iteration
        int next = (i + 1) % nns;
        System.err.println("==============================\n"
            + "[Starting] Failing over from " + i + "->" + next + "\n"
            + "==============================");
        cluster.transitionToStandby(i);
        cluster.transitionToActive(next);
        System.err.println("==============================\n"
            + "[Completed] Failing over from " + i + "->" + next + ". Sleeping for "+
            (msBetweenFailovers/1000) +"sec \n"
            + "==============================");
        Thread.sleep(msBetweenFailovers);
      }
    }
  });
}
 

import org.apache.hadoop.test.MultithreadedTestUtil.RepeatingTestThread; //导入依赖的package包/类
/**
 * Regression test for HDFS-2693: when doing state transitions, we need to
 * lock the FSNamesystem so that we don't end up doing any writes while it's
 * "in between" states.
 * This test case starts up several client threads which do mutation operations
 * while flipping a NN back and forth from active to standby.
 */
@Test(timeout=120000)
public void testTransitionSynchronization() throws Exception {
  Configuration conf = new Configuration();
  final MiniDFSCluster cluster = new MiniDFSCluster.Builder(conf)
    .nnTopology(MiniDFSNNTopology.simpleHATopology())
    .numDataNodes(0)
    .build();
  try {
    cluster.waitActive();
    ReentrantReadWriteLock spyLock = NameNodeAdapter.spyOnFsLock(
        cluster.getNameNode(0).getNamesystem());
    Mockito.doAnswer(new GenericTestUtils.SleepAnswer(50))
      .when(spyLock).writeLock();
    
    final FileSystem fs = HATestUtil.configureFailoverFs(
        cluster, conf);
    
    TestContext ctx = new TestContext();
    for (int i = 0; i < 50; i++) {
      final int finalI = i;
      ctx.addThread(new RepeatingTestThread(ctx) {
        @Override
        public void doAnAction() throws Exception {
          Path p = new Path("/test-" + finalI);
          fs.mkdirs(p);
          fs.delete(p, true);
        }
      });
    }
    
    ctx.addThread(new RepeatingTestThread(ctx) {
      @Override
      public void doAnAction() throws Exception {
        cluster.transitionToStandby(0);
        Thread.sleep(50);
        cluster.transitionToActive(0);
      }
    });
    ctx.startThreads();
    ctx.waitFor(20000);
    ctx.stop();
  } finally {
    cluster.shutdown();
  }
}