@AfterClass
 public static void stopThreadPool() {
   if (threadPool != null) {
     threadPool.shutdownNow();
     threadPool = null;
   }
 }
  @AfterMethod
  public void tearDown() throws Exception {
    replicaEngine.close();
    storeReplica.close();

    engine.close();
    store.close();

    if (threadPool != null) {
      threadPool.shutdownNow();
    }
  }
  public void testShutdownNowInterrupts() throws Exception {
    String threadPoolName = randomThreadPool(ThreadPool.ThreadPoolType.FIXED);
    ThreadPool threadPool = null;
    try {
      Settings nodeSettings =
          Settings.builder()
              .put("threadpool." + threadPoolName + ".queue_size", 1000)
              .put("node.name", "testShutdownNowInterrupts")
              .build();
      threadPool = new ThreadPool(nodeSettings);
      ClusterSettings clusterSettings =
          new ClusterSettings(nodeSettings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
      threadPool.setClusterSettings(clusterSettings);
      assertEquals(info(threadPool, threadPoolName).getQueueSize().getSingles(), 1000L);

      final CountDownLatch latch = new CountDownLatch(1);
      ThreadPoolExecutor oldExecutor = (ThreadPoolExecutor) threadPool.executor(threadPoolName);
      threadPool
          .executor(threadPoolName)
          .execute(
              () -> {
                try {
                  new CountDownLatch(1).await();
                } catch (InterruptedException ex) {
                  latch.countDown();
                  Thread.currentThread().interrupt();
                }
              });
      clusterSettings.applySettings(
          Settings.builder().put("threadpool." + threadPoolName + ".queue_size", 2000).build());
      assertThat(threadPool.executor(threadPoolName), not(sameInstance(oldExecutor)));
      assertThat(oldExecutor.isShutdown(), equalTo(true));
      assertThat(oldExecutor.isTerminating(), equalTo(true));
      assertThat(oldExecutor.isTerminated(), equalTo(false));
      threadPool.shutdownNow(); // should interrupt the thread
      latch.await(
          3, TimeUnit.SECONDS); // If this throws then ThreadPool#shutdownNow didn't interrupt
    } finally {
      terminateThreadPoolIfNeeded(threadPool);
    }
  }
  public static void main(String[] args) {
    final String executor = ThreadPool.Names.GENERIC;
    final boolean waitForRequest = true;
    final ByteSizeValue payloadSize = new ByteSizeValue(100, ByteSizeUnit.BYTES);
    final int NUMBER_OF_CLIENTS = 10;
    final int NUMBER_OF_ITERATIONS = 100000;
    final byte[] payload = new byte[(int) payloadSize.bytes()];
    final AtomicLong idGenerator = new AtomicLong();
    final Type type = Type.NETTY;

    Settings settings = ImmutableSettings.settingsBuilder().build();

    final ThreadPool serverThreadPool = new ThreadPool();
    final TransportService serverTransportService =
        new TransportService(type.newTransport(settings, serverThreadPool), serverThreadPool)
            .start();

    final ThreadPool clientThreadPool = new ThreadPool();
    final TransportService clientTransportService =
        new TransportService(type.newTransport(settings, clientThreadPool), clientThreadPool)
            .start();

    final DiscoveryNode node =
        new DiscoveryNode("server", serverTransportService.boundAddress().publishAddress());

    serverTransportService.registerHandler(
        "benchmark",
        new BaseTransportRequestHandler<BenchmarkMessage>() {
          @Override
          public BenchmarkMessage newInstance() {
            return new BenchmarkMessage();
          }

          @Override
          public String executor() {
            return executor;
          }

          @Override
          public void messageReceived(BenchmarkMessage request, TransportChannel channel)
              throws Exception {
            channel.sendResponse(request);
          }
        });

    clientTransportService.connectToNode(node);

    for (int i = 0; i < 10000; i++) {
      BenchmarkMessage message = new BenchmarkMessage(1, payload);
      clientTransportService
          .submitRequest(
              node,
              "benchmark",
              message,
              new BaseTransportResponseHandler<BenchmarkMessage>() {
                @Override
                public BenchmarkMessage newInstance() {
                  return new BenchmarkMessage();
                }

                @Override
                public String executor() {
                  return ThreadPool.Names.SAME;
                }

                @Override
                public void handleResponse(BenchmarkMessage response) {}

                @Override
                public void handleException(TransportException exp) {
                  exp.printStackTrace();
                }
              })
          .txGet();
    }

    Thread[] clients = new Thread[NUMBER_OF_CLIENTS];
    final CountDownLatch latch = new CountDownLatch(NUMBER_OF_CLIENTS * NUMBER_OF_ITERATIONS);
    for (int i = 0; i < NUMBER_OF_CLIENTS; i++) {
      clients[i] =
          new Thread(
              new Runnable() {
                @Override
                public void run() {
                  for (int j = 0; j < NUMBER_OF_ITERATIONS; j++) {
                    final long id = idGenerator.incrementAndGet();
                    BenchmarkMessage message = new BenchmarkMessage(id, payload);
                    BaseTransportResponseHandler<BenchmarkMessage> handler =
                        new BaseTransportResponseHandler<BenchmarkMessage>() {
                          @Override
                          public BenchmarkMessage newInstance() {
                            return new BenchmarkMessage();
                          }

                          @Override
                          public String executor() {
                            return executor;
                          }

                          @Override
                          public void handleResponse(BenchmarkMessage response) {
                            if (response.id != id) {
                              System.out.println(
                                  "NO ID MATCH [" + response.id + "] and [" + id + "]");
                            }
                            latch.countDown();
                          }

                          @Override
                          public void handleException(TransportException exp) {
                            exp.printStackTrace();
                            latch.countDown();
                          }
                        };

                    if (waitForRequest) {
                      clientTransportService
                          .submitRequest(node, "benchmark", message, handler)
                          .txGet();
                    } else {
                      clientTransportService.sendRequest(node, "benchmark", message, handler);
                    }
                  }
                }
              });
    }

    StopWatch stopWatch = new StopWatch().start();
    for (int i = 0; i < NUMBER_OF_CLIENTS; i++) {
      clients[i].start();
    }

    try {
      latch.await();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    stopWatch.stop();

    System.out.println(
        "Ran ["
            + NUMBER_OF_CLIENTS
            + "], each with ["
            + NUMBER_OF_ITERATIONS
            + "] iterations, payload ["
            + payloadSize
            + "]: took ["
            + stopWatch.totalTime()
            + "], TPS: "
            + (NUMBER_OF_CLIENTS * NUMBER_OF_ITERATIONS) / stopWatch.totalTime().secondsFrac());

    clientTransportService.close();
    clientThreadPool.shutdownNow();

    serverTransportService.close();
    serverThreadPool.shutdownNow();
  }
 @After
 public void cleanUp() throws Exception {
   testThreadPool.shutdownNow();
 }
Exemple #6
0
 @After
 public void cleanup() {
   threadPool.shutdownNow();
 }