Пример #1
1
 private Set<Thread> collectCurrentThreads() {
   Thread[] activeThreadsT = new Thread[Thread.activeCount()];
   Thread.enumerate(activeThreadsT);
   Set<Thread> res = new HashSet<Thread>();
   for (Thread t : activeThreadsT) res.add(t);
   return res;
 }
 private boolean hasRetrievers() {
   Thread[] threads = new Thread[Thread.activeCount()];
   int numThreads = Thread.enumerate(threads);
   for (int i = 0; i < numThreads; i++) {
     if (threads[i].getName().startsWith(RUNNING_THREAD_NAME_PREFIX)) return true;
   }
   return false;
 }
 private static void listThreads() {
   int ac = Thread.activeCount();
   if (ac > 0) {
     Thread[] tlist = new Thread[ac];
     Thread.enumerate(tlist);
     for (Thread t : tlist) {
       System.out.println("Thread [" + t + "] => {" + t.getClass().getName() + "}");
     }
   }
 }
Пример #4
1
  @Override
  public String format(LogRecord record) {

    int count = Thread.activeCount();

    Thread th[] = new Thread[count];
    // returns the number of threads put into the array
    Thread.enumerate(th);

    String thrName = null;

    // prints active threads
    for (int i = 0; i < count; i++) {

      if (th[i] != null && th[i].getId() == record.getThreadID()) {

        thrName = th[i].getName();
        break;
      }
    }

    if (thrName == null) {
      thrName = String.format("id:%d", record.getThreadID());
    }

    StringBuilder sb = new StringBuilder();

    sb.append(new Date(record.getMillis()))
        .append(" ")
        .append(record.getLevel().getLocalizedName())
        .append(" ")
        .append("[")
        .append(record.getSourceClassName())
        .append("]")
        .append("{")
        .append(thrName)
        .append("}: ")
        .append(formatMessage(record))
        .append(LINE_SEPARATOR);

    if (record.getThrown() != null) {
      try {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        record.getThrown().printStackTrace(pw);
        pw.close();
        sb.append(sw.toString());
      } catch (Exception ex) {
        // ignore
      }
    }

    return "RT: " + sb.toString();
  }
 protected void endIdegaDatabasePool() {
   PoolManager.getInstance().release();
   int count = Thread.activeCount();
   Thread[] threads = new Thread[count];
   Thread.enumerate(threads);
   for (int i = 0; i < threads.length; i++) {
     Thread thread = threads[i];
     String name = (thread == null) ? null : thread.getName();
     // System.out.println(name);
     if (name != null && name.startsWith("HSQLDB")) {
       thread.interrupt();
     }
   }
 }
Пример #6
1
 @Override
 public void run() {
   boolean loop = true;
   try {
     while (loop) {
       final Thread[] all = new Thread[Thread.activeCount() + 100];
       final int count = Thread.enumerate(all);
       loop = false;
       for (int i = 0; i < count; i++) {
         final Thread t = all[i];
         // daemon: skip it.
         if (t.isDaemon()) continue;
         // RMI Reaper: skip it.
         if (t.getName().startsWith("RMI Reaper")) continue;
         if (t.getName().startsWith("DestroyJavaVM")) continue;
         // Non daemon, non RMI Reaper: join it, break the for
         // loop, continue in the while loop (loop=true)
         loop = true;
         try {
           // Found a non-daemon thread. Wait for it.
           t.join();
         } catch (Exception ex) {
           ex.printStackTrace();
         }
         break;
       }
     }
     // We went through a whole for-loop without finding any thread
     // to join. We can close cs.
   } catch (Exception ex) {
     ex.printStackTrace();
   } finally {
     try {
       // if we reach here it means the only non-daemon threads
       // that remain are reaper threads - or that we got an
       // unexpected exception/error.
       //
       if (cs != null && cs.isActive()) {
         cs.stop();
       }
     } catch (Exception ex) {
       ex.printStackTrace();
     }
   }
 }
Пример #7
1
 // Enumerate all active threads
 private Thread[] enumerateThreads() {
   boolean fits = false;
   int inc = 50;
   Thread[] threads = null;
   int nrThreads = 0;
   while (!fits) {
     try {
       threads = new Thread[Thread.activeCount() + inc];
       nrThreads = Thread.enumerate(threads);
       fits = true;
     } catch (ArrayIndexOutOfBoundsException exp) {
       inc += 50;
     }
   }
   // Trim array
   Thread ret[] = new Thread[nrThreads];
   System.arraycopy(threads, 0, ret, 0, nrThreads);
   return ret;
 }
  // @Test
  public void rawEpochStealing() throws Exception {
    RealEventHubUtilities utils = new RealEventHubUtilities();
    utils.setup(-1);

    int clientSerialNumber = 0;
    while (true) {
      Thread[] blah = new Thread[Thread.activeCount() + 10];
      int actual = Thread.enumerate(blah);
      if (actual >= blah.length) {
        System.out.println("Lost some threads");
      }
      int parkedCount = 0;
      String selectingList = "";
      boolean display = true;
      for (int i = 0; i < actual; i++) {
        display = true;
        StackTraceElement[] bloo = blah[i].getStackTrace();
        String show = "nostack";
        if (bloo.length > 0) {
          show = bloo[0].getClassName() + "." + bloo[0].getMethodName();
          if (show.compareTo("sun.misc.Unsafe.park") == 0) {
            parkedCount++;
            display = false;
          } else if (show.compareTo("sun.nio.ch.WindowsSelectorImpl$SubSelector.poll0") == 0) {
            selectingList += (" " + blah[i].getId());
            display = false;
          }
        }
        if (display) {
          System.out.print(" " + blah[i].getId() + ":" + show);
        }
      }
      System.out.println("\nParked: " + parkedCount + "  SELECTING: " + selectingList);

      System.out.println("Client " + clientSerialNumber + " starting");
      EventHubClient client =
          EventHubClient.createFromConnectionStringSync(utils.getConnectionString().toString());
      PartitionReceiver receiver =
          client
              .createEpochReceiver(
                  utils.getConsumerGroup(), "0", PartitionReceiver.START_OF_STREAM, 1)
              .get();

      boolean useReceiveHandler = false;

      if (useReceiveHandler) {
        Blah b = new Blah(clientSerialNumber++, receiver, client);
        receiver.setReceiveHandler(b).get();
        // wait for messages to start flowing
        b.waitForReceivedMessages().get();
      } else {
        receiver.receiveSync(1);
        System.out.println("Received a message");
      }

      // Enable these lines to avoid overlap
      /* */
      try {
        System.out.println("Non-overlap close of PartitionReceiver");
        if (useReceiveHandler) {
          receiver.setReceiveHandler(null).get();
        }
        receiver.close().get();
      } catch (InterruptedException | ExecutionException e) {
        System.out.println(
            "Client "
                + clientSerialNumber
                + " failed while closing PartitionReceiver: "
                + e.toString());
      }
      try {
        System.out.println("Non-overlap close of EventHubClient");
        client.close().get();
      } catch (InterruptedException | ExecutionException e) {
        System.out.println(
            "Client "
                + clientSerialNumber
                + " failed while closing EventHubClient: "
                + e.toString());
      }
      System.out.println("Client " + clientSerialNumber + " closed");
      /* */

      System.out.println("Threads: " + Thread.activeCount());
    }
  }
Пример #9
0
 @Override
 protected void onPreExecute() {
   Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
   Log.d(TAG, "threads: " + Thread.activeCount());
   super.onPreExecute();
   Log.d(TAG, "onPreExecute");
 }
  @Before
  public void setup() throws Exception {
    int ret;
    //
    // adding a delete before creating a keystore
    //
    try {
      if (ksFile != null) {
        if (ksFile.exists()) {
          System.out.println(
              "Keystore File [" + ksFile.getAbsolutePath() + "] is available - and deleting");
          ksFile.delete();
          System.out.println("Keystore File [" + ksFile.getAbsolutePath() + "] is deleted.");
        } else {
          System.out.println("Keystore File [" + ksFile.getAbsolutePath() + "] is not available");
        }
      } else {
        System.out.println("Keystore File is NULL");
      }
    } catch (Throwable t) {
      t.printStackTrace();
    }

    Configuration conf = new Configuration();
    CredentialShell cs = new CredentialShell();
    cs.setConf(conf);
    try {
      ret = cs.run(argsCreate);
    } catch (Exception e) {
      throw e;
    }
    assertEquals(0, ret);
    System.out.println("(1) Number of active Threads : " + Thread.activeCount());
    listThreads();
  }
Пример #11
0
  public static void main(String[] args) throws IOException {
    final WebCrawler wc = new WebCrawler();
    Word.readWordList();
    for (String word : Word.wordList) {
      wc.addUrl(Word.wordUrl + word, 1);
    }

    long start = System.currentTimeMillis();
    System.out.println("开始爬虫……");
    wc.begin();

    while (true) {
      StringBuffer response = null;
      synchronized (wc.responseList) {
        if (!wc.responseList.isEmpty()) {
          response = wc.responseList.get(0);
          wc.responseList.remove(0);
        }
      }
      if (response != null) { // got a response
        new Word(response);
      }

      // 所有爬虫线程都处于等待状态,而且url池已经空了
      if (wc.uncrawledUrlList.isEmpty() && Thread.activeCount() == 1
          || wc.waitingThreadCount == wc.threadNumber) {
        long end = System.currentTimeMillis();
        System.out.println("总共抓取了" + wc.allUrlList.size() + "个网页。");
        System.out.println("总共耗时" + (end - start) / 1000 + "秒。");
        System.exit(1);
      }
    }
  }
Пример #12
0
  public static void main(String[] args) {

    ExecutorTest executorTest = new ExecutorTest();
    executorTest.test();

    System.out.println("Number of active threads is : " + Thread.activeCount());
    System.out.println("Main thread will exit...");
  }
Пример #13
0
  public void execute(Scanner scanner) {
    boolean isReloading = CronFireSettings.getSettingBoolean("_internal_is_reloading", false);

    // Don't reload if we're already reloading.
    if (isReloading) return;

    // Pause (save original state)
    boolean isPaused = queue.isPaused();
    queue.pause(true);
    CronFireSettings.setSetting("_internal_is_reloading", "true");

    // Wait for all jobs to finish
    int numThreads = Thread.activeCount() - 3; // Compensate for built-in
    int numWaits = 0;

    if (numThreads > 0) {
      System.out.println("Waiting for running jobs to finish...");
      while (numThreads > 0) {
        numThreads = Thread.activeCount() - 3;
        try {
          Thread.sleep(250);
        } catch (Exception e) {
        }

        if (numWaits > 1200) {
          System.out.println("Waiting too long for jobs to finish... aborting RELOAD");
          CronFireSettings.setSetting("_internal_is_reloading", "false");
          return;
        }
      }

      System.out.println("Reloading...");
    }

    // Reload config and URL files (merge changes)
    queue.empty();
    CronFireSettings.loadConfigFile(CronFireSettings.getSetting("config_file"));
    CronFireSettings.loadUrls(CronFireSettings.getSetting("urls_file"));

    // Unpause (or resume original state)
    queue.pause(isPaused);

    System.out.println("Reloaded...");
    CronFireSettings.setSetting("_internal_is_reloading", "false");
  }
Пример #14
0
 private void acceptConnections() {
   for (; ; ) {
     try {
       String handlerName = fullName + "-Handler-" + Thread.activeCount();
       new Thread(new ClientHandler(socket.accept()), handlerName).start();
     } catch (Exception ex) {
       Log.warn(fullName + ": exception accepting connection.", ex);
     }
   }
 }
 public void printStats(String status) {
   // String str = Thread.currentThread().getName().split("@@")[0];
   // Thread.currentThread().setName(String.valueOf(Thread.currentThread().getId()));
   LOG.info(
       "{} {} {} [Active Threads: {}] ",
       Thread.currentThread().getId(),
       Thread.currentThread().getName(),
       status,
       Thread.activeCount());
 }
 @Test
 public void testCredentialProvider() {
   // test credential provider is registered and return credential providers.
   cp = new RangerCredentialProvider();
   providers = cp.getCredentialProviders(url);
   if (providers != null) {
     assertTrue(url.equals(providers.get(0).toString()));
   }
   System.out.println("(2) Number of active Threads : " + Thread.activeCount());
   listThreads();
 }
Пример #17
0
  /**
   * Runs the same model many times and ensures it is not creating many threads which would finish
   * blocking the JVM
   */
  @Test
  public void testModelUsageOfThreads() {

    // first runs after which the reference will be taken
    final int HEATING_COUNT = 2;
    final int TEST_COUNT = 10;

    // heading period
    for (int i = 0; i < HEATING_COUNT; i++) runModel();

    // take reference
    final int activeThreads = Thread.activeCount();
    final Set<Thread> activeThreadsSet = collectCurrentThreads();

    // run many
    for (int i = 0; i < TEST_COUNT; i++) {
      System.err.println("exec " + i + " threads " + Thread.activeCount());
      runModel();
    }

    if (Thread.activeCount() > activeThreads) {
      double nbPerIteration = Thread.activeCount() / TEST_COUNT;
      Set<Thread> threadsNow = collectCurrentThreads();
      threadsNow.removeAll(activeThreadsSet);
      for (Thread t : threadsNow) {
        System.err.println("extra thread: " + t);
        t.stop();
      }
      Thread.yield();
      System.out.println("did cleaning help ? " + Thread.activeCount() + " / " + activeThreads);
      threadsNow = collectCurrentThreads();
      threadsNow.removeAll(activeThreadsSet);
      for (Thread t : threadsNow) {
        System.out.println("extra thread: " + t);
      }
      fail(
          "about "
              + nbPerIteration
              + " novel threads are created at each run; this cannot be used in production");
    }
  }
 @Test
 public void testCredentialString() {
   // test credential provider created is returning the correct credential string.
   cp = new RangerCredentialProvider();
   providers = cp.getCredentialProviders(url);
   if (providers != null) {
     assertTrue(
         "PassworD123".equals(new String(cp.getCredentialString(url, "TestCredential001"))));
   }
   System.out.println("(3) Number of active Threads : " + Thread.activeCount());
   listThreads();
 }
Пример #19
0
 private String readFileHeader(String filename) {
   String value;
   try {
     value = WaarpStringUtils.readFileException(filename);
   } catch (InvalidArgumentException e) {
     logger.error("Error while trying to open: " + filename, e);
     return "";
   } catch (FileTransferException e) {
     logger.error("Error while trying to read: " + filename, e);
     return "";
   }
   StringBuilder builder = new StringBuilder(value);
   WaarpStringUtils.replace(
       builder,
       REPLACEMENT.XXXLOCALXXX.toString(),
       Integer.toString(Configuration.configuration.getLocalTransaction().getNumberLocalChannel())
           + " "
           + Thread.activeCount());
   WaarpStringUtils.replace(
       builder,
       REPLACEMENT.XXXNETWORKXXX.toString(),
       Integer.toString(
           Configuration.configuration.getLocalTransaction().getNumberLocalChannel()));
   WaarpStringUtils.replace(
       builder, REPLACEMENT.XXXHOSTIDXXX.toString(), Configuration.configuration.getHOST_ID());
   if (authentHttp.isAuthenticated()) {
     WaarpStringUtils.replace(
         builder,
         REPLACEMENT.XXXADMINXXX.toString(),
         Messages.getString("HttpSslHandler.1")); // $NON-NLS-1$
   } else {
     WaarpStringUtils.replace(
         builder,
         REPLACEMENT.XXXADMINXXX.toString(),
         Messages.getString("HttpSslHandler.0")); // $NON-NLS-1$
   }
   TrafficCounter trafficCounter =
       Configuration.configuration.getGlobalTrafficShapingHandler().trafficCounter();
   WaarpStringUtils.replace(
       builder,
       REPLACEMENT.XXXBANDWIDTHXXX.toString(),
       Messages.getString("HttpSslHandler.IN")
           + (trafficCounter.lastReadThroughput() >> 20)
           + //$NON-NLS-1$
           Messages.getString("HttpSslHandler.MOPS")
           + //$NON-NLS-1$
           Messages.getString("HttpSslHandler.OUT")
           + //$NON-NLS-1$
           (trafficCounter.lastWriteThroughput() >> 20)
           + Messages.getString("HttpSslHandler.MOPS")); // $NON-NLS-1$
   WaarpStringUtils.replace(builder, REPLACEMENT.XXXLANGXXX.toString(), lang);
   return builder.toString();
 }
    @Override
    // Perform actual service task - runs in new thread
    protected Void doInBackground(Void... params) {
      Log.i(this.getClass().getName(), "Current Threadname " + Thread.currentThread().getName());
      Log.i(this.getClass().getName(), "Current Thread count" + Thread.activeCount());

      for (int i = 1; i <= FIBONACCI_LIMIT; i++) {
        Log.i(this.getClass().getName(), "Fibonacci number " + i + ": " + fib(i));
        // Update progress
        publishProgress((int) ((i / (float) FIBONACCI_LIMIT) * 100));
      }
      publishProgress(100);
      return null;
    }
 @After
 public void teardown() throws Exception {
   System.out.println("In teardown : Number of active Threads : " + Thread.activeCount());
   int ret;
   Configuration conf = new Configuration();
   CredentialShell cs = new CredentialShell();
   cs.setConf(conf);
   try {
     ret = cs.run(argsDelete);
   } catch (Exception e) {
     throw e;
   }
   assertEquals(0, ret);
   listThreads();
 }
  public void run() {
    try {
      HostNodeDao nodeDao = new HostNodeDao();
      // 得到被监视的防火墙设备
      List nodeList = nodeDao.loadNetwork(8);
      for (int i = 0; i < nodeList.size(); i++) {
        HostNode node = (HostNode) nodeList.get(i);
      }
      Vector vector = null;
      int numTasks = nodeList.size();
      int numThreads = 200;

      try {
        List numList = new ArrayList();
        TaskXml taskxml = new TaskXml();
        numList = taskxml.ListXml();
        for (int i = 0; i < numList.size(); i++) {
          Task task = new Task();
          BeanUtils.copyProperties(task, numList.get(i));
          if (task.getTaskname().equals("netthreadnum")) {
            numThreads = task.getPolltime().intValue();
          }
        }

      } catch (Exception e) {
        e.printStackTrace();
      }

      // 生成线程池
      ThreadPool threadPool = null;
      if (nodeList != null && nodeList.size() > 0) {
        threadPool = new ThreadPool(nodeList.size());
        // 运行任务
        for (int i = 0; i < nodeList.size(); i++) {
          threadPool.runTask(createTask((HostNode) nodeList.get(i)));
        }
        // 关闭线程池并等待所有任务完成
        threadPool.join();
        threadPool.close();
      }
      threadPool = null;

    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      SysLogger.info("********Firewall Thread Count : " + Thread.activeCount());
    }
  }
Пример #23
0
  /** @param args */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    Thread[] threads = new Thread[THREADS_COUNT];
    final Object o = new Object();
    for (int i = 0; i < THREADS_COUNT; i++) {
      threads[i] =
          new Thread(
              new Runnable() {

                @Override
                public void run() {
                  // TODO Auto-generated method stub
                  synchronized (o) {
                    for (int i = 0; i < 1000; i++) {
                      increase();
                      try {
                        // Thread.sleep(2);
                        o.wait();
                      } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                      }
                    }
                  }
                }
              });

      threads[i].start();
    }

    while (Thread.activeCount() > 1) {
      synchronized (o) {
        o.notify();
      }
      Thread.yield();
    }
    System.out.println(race);
  }
Пример #24
0
  private void createScene() {
    // defining the axes
    NumberAxis xAxis = new NumberAxis(0, 105, 10);
    NumberAxis yAxis = new NumberAxis();
    xAxis.setLabel("Quality %");
    yAxis.setLabel("User Interactions");
    yAxis.forceZeroInRangeProperty();
    //        xAxis.setMinorTickCount(0);
    //        yAxis.setMinorTickCount(0);
    // creating the chart
    if (chartType == null) {
      chartType = Constant.AREA_CHART;
      // overlapping area colors
      this.chart = new AreaChart<Number, Number>(xAxis, yAxis);
      //            this.chart = new StackedAreaChart<Number, Number>(xAxis, yAxis);
    } else if (chartType.equals(Constant.LINE_CHART)) {
      this.chart = new LineChart<Number, Number>(xAxis, yAxis);
    } else {
      // overlapping area colors
      this.chart = new AreaChart<Number, Number>(xAxis, yAxis);
      //            this.chart = new StackedAreaChart<Number, Number>(xAxis, yAxis);
    }
    if (logger.isDebugEnabled()) logger.debug("Chart created: " + this.chart);
    chart.setAnimated(true);
    scene = new Scene(chart, 600, 400);
    chart
        .getStylesheets()
        .add(this.getClass().getResource(Constant.FOLDER_CONF + "styleChart.css").toExternalForm());
    createSeries(chart);
    //        seriesOs = FXCollections.observableArrayList();
    //        createObservableSeries();
    //        chart.setData(seriesOs);

    chart.setLegendSide(Side.TOP);
    logger.debug("Thread chart active: " + Thread.activeCount());
  }
Пример #25
0
  public void run() {
    ByteBuffer buf = ByteBuffer.allocate(UDPMessageSender.MAX_MSG_SIZE);
    InetSocketAddress srcAddr = null;

    while (true) {
      // receive
      buf.clear();
      try {
        srcAddr = (InetSocketAddress) this.sock.receive(buf);
      } catch (IOException e) {
        logger.log(
            Level.WARNING,
            "DatagramSocket#receive() threw an Exception and the receiver will die.");
        return;
      }
      buf.rewind();

      logger.log(Level.INFO, "Source address: " + srcAddr);

      // construct a message
      Message msg;
      try {
        msg = Message.decode(buf);
      } catch (IOException e) {
        logger.log(Level.WARNING, "Could not decode the received message (corrupted ?).", e);
        continue;
      }

      // check signature
      byte[] acceptableSig = this.provider.getMessageSignature();
      byte[] sig = msg.getSignature();
      /*
      System.out.println("signature:");
      System.out.print(" acceptable:");
      for (int i = 0; i < acceptableSig.length; i++)
      System.out.print(" " + Integer.toHexString(acceptableSig[i] & 0xff));
      System.out.println();
      System.out.print(" message:   ");
      for (int i = 0; i < acceptableSig.length; i++)
      System.out.print(" " + Integer.toHexString(sig[i] & 0xff));
      System.out.println();
      */
      if (!Signature.match(sig, acceptableSig)) continue;

      // invoke a Thread handling the incoming Message
      Runnable r = new UDPMessageHandler(srcAddr, msg);

      try {
        if (this.config.getUseThreadPool()) { // note: does not register to handlerThreads
          this.provider.getThreadPool().submit(r);
        } else {
          Thread thr = new Thread(r);
          thr.setDaemon(false);

          handlerThreads.add(thr);

          thr.start();
        }
      } catch (OutOfMemoryError e) {
        logger.log(Level.SEVERE, "# of threads: " + Thread.activeCount(), e);

        //				synchronized (UDPMessageReceiver.class) {
        //					if (!UDPMessageReceiver.oomPrinted) {
        //						UDPMessageReceiver.oomPrinted = true;
        //
        //						Thread[] tarray = new Thread[Thread.activeCount()];
        //						Thread.enumerate(tarray);
        //						for (Thread t: tarray) if (t != null) System.out.println("Th: " + t.getName());
        //						System.out.flush();
        //					}
        //				}

        throw e;
      }
    } // while (true)
  }
Пример #26
0
  /**
   * Runs the same model many times in parallel and ensures it is still giving relevant results
   * would finish blocking the JVM
   */
  @Test
  public void testModelParallel() {

    ListsOfMessages.getGenlabMessages()
        .setFilterIgnoreBelow(MessageLevel.TRACE, MessageLevel.TRACE);

    int countThreadBeginning = Thread.activeCount();

    final int PARALLELL_THREADS = 10;

    class ThreadRunModel extends Thread {

      private final Set<ThreadRunModel> threadsToWait;

      public ThreadRunModel(Set<ThreadRunModel> threadsToWait) {
        setDaemon(false);
        this.threadsToWait = threadsToWait;
      }

      @Override
      public void run() {

        for (int i = 0; i < 30; i++) {
          System.err.println("wait");
          // wait a bit randomly
          try {
            Thread.sleep((long) (2000 * Math.random()));
          } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
          // run the model
          System.err.println("run !");
          Map<String, Object> result = runModel();
          checkResult(result);
        }
        // return
        synchronized (threadsToWait) {
          this.threadsToWait.remove(this);
        }
      }
    }

    final Set<ThreadRunModel> threadsToWait = new HashSet<ThreadRunModel>();

    // create threads
    for (int i = 0; i < PARALLELL_THREADS; i++) {
      threadsToWait.add(new ThreadRunModel(threadsToWait));
    }

    // start threads
    for (ThreadRunModel t : threadsToWait) {
      t.start();
    }

    // wait for all of them to finish
    while (true) {
      synchronized (threadsToWait) {
        if (threadsToWait.isEmpty()) break;
        System.out.println("waiting for " + threadsToWait.size() + " model threads");
      }
      try {
        Thread.sleep(500);
      } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }

    System.out.println(
        "thread count: before " + countThreadBeginning + ", after " + Thread.activeCount());
  }
  public String getServerStatus() {
    int playerCount = 0, objectCount = 0;
    int max = LoginServerThread.getInstance().getMaxPlayer();

    playerCount = L2World.getInstance().getAllPlayersCount();
    objectCount = L2World.getInstance().getVisibleObjectsCount();

    int itemCount = 0;
    int itemVoidCount = 0;
    int monsterCount = 0;
    int minionCount = 0;
    int minionsGroupCount = 0;
    int npcCount = 0;
    int charCount = 0;
    int pcCount = 0;
    int detachedCount = 0;
    int doorCount = 0;
    int summonCount = 0;
    int AICount = 0;

    for (L2Object obj : L2World.getInstance().getVisibleObjects()) {
      if (obj == null) {
        continue;
      }
      if (obj instanceof L2Character) {
        if (((L2Character) obj).hasAI()) {
          AICount++;
        }
      }
      if (obj instanceof L2ItemInstance) {
        if (((L2ItemInstance) obj).getItemLocation() == ItemLocation.VOID) {
          itemVoidCount++;
        } else {
          itemCount++;
        }
      } else if (obj instanceof L2MonsterInstance) {
        monsterCount++;
        if (((L2MonsterInstance) obj).hasMinions()) {
          minionCount += ((L2MonsterInstance) obj).getMinionList().countSpawnedMinions();
          minionsGroupCount +=
              ((L2MonsterInstance) obj).getMinionList().lazyCountSpawnedMinionsGroups();
        }
      } else if (obj instanceof L2Npc) {
        npcCount++;
      } else if (obj instanceof L2PcInstance) {
        pcCount++;
        if ((((L2PcInstance) obj).getClient() != null)
            && ((L2PcInstance) obj).getClient().isDetached()) {
          detachedCount++;
        }
      } else if (obj instanceof L2Summon) {
        summonCount++;
      } else if (obj instanceof L2DoorInstance) {
        doorCount++;
      } else if (obj instanceof L2Character) {
        charCount++;
      }
    }
    StringBuilder sb = new StringBuilder();
    sb.append("Server Status: ");
    sb.append("\r\n  --->  Player Count: " + playerCount + "/" + max);
    sb.append("\r\n  ---> Offline Count: " + detachedCount + "/" + playerCount);
    sb.append("\r\n  +-->  Object Count: " + objectCount);
    sb.append("\r\n  +-->      AI Count: " + AICount);
    sb.append("\r\n  +.... L2Item(Void): " + itemVoidCount);
    sb.append("\r\n  +.......... L2Item: " + itemCount);
    sb.append("\r\n  +....... L2Monster: " + monsterCount);
    sb.append("\r\n  +......... Minions: " + minionCount);
    sb.append("\r\n  +.. Minions Groups: " + minionsGroupCount);
    sb.append("\r\n  +........... L2Npc: " + npcCount);
    sb.append("\r\n  +............ L2Pc: " + pcCount);
    sb.append("\r\n  +........ L2Summon: " + summonCount);
    sb.append("\r\n  +.......... L2Door: " + doorCount);
    sb.append("\r\n  +.......... L2Char: " + charCount);
    sb.append("\r\n  --->   Ingame Time: " + gameTime());
    sb.append("\r\n  ---> Server Uptime: " + getUptime(uptime));
    sb.append("\r\n  --->      GM Count: " + getOnlineGMS());
    sb.append("\r\n  --->       Threads: " + Thread.activeCount());
    sb.append(
        "\r\n  RAM Used: "
            + ((Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory())
                / 1048576)); // 1024 * 1024 = 1048576
    sb.append("\r\n");

    return sb.toString();
  }
Пример #28
0
  public void getWebByHomePage() {
    startTime = System.currentTimeMillis();
    this.myDomain = getDomain();
    if (this.myDomain == null) {
      System.out.println("Wrong input!");
      return;
    }
    System.out.println("Homepage=" + strHomePage);
    addReport("Homepage=" + strHomePage + "!\n");
    System.out.println("Domain=" + myDomain);
    addReport("Domain=" + myDomain + "!\n");
    arrUrl.add(strHomePage);
    arrUrls.add(strHomePage);
    allUrls.put(strHomePage, 1);
    deepUrls.put(strHomePage, 1);
    File fDir = new File(fPath);
    if (!fDir.exists()) {
      fDir.mkdir();
    }
    System.out.println("Start!");
    this.addReport("Start!\n");
    String tmp = getAUrl();
    this.getWebByUrl(tmp, charset, allUrls.get(tmp) + "");
    int i = 0;
    for (i = 0; i < intThreadNum; i++) {
      new Thread(new Processer(this)).start();
    }
    while (true) {
      if (arrUrls.isEmpty() && Thread.activeCount() == 1) {
        long finishTime = System.currentTimeMillis();
        long costTime = finishTime - startTime;
        System.out.println("\n\n\n\nFinished!");
        addReport("\n\n\n\nFinished!\n");
        System.out.println(
            "StartTime=" + startTime + "FinishTime=" + finishTime + "CostTime=" + costTime + "ms");
        addReport(
            "StartTime="
                + startTime
                + "FinishTime="
                + finishTime
                + "CostTime="
                + costTime
                + "ms"
                + "\n");
        System.out.println(
            "Total url number="
                + (webSuccessed + webFailed)
                + "Successed:"
                + webSuccessed
                + "Failed:"
                + webFailed);
        addReport(
            "Total url number="
                + (webSuccessed + webFailed)
                + "Successed:"
                + webSuccessed
                + "Failed:"
                + webFailed
                + "\n");

        String strIndex = "";
        String tmpUrl = "";
        while (!arrUrl.isEmpty()) {
          tmpUrl = getUrl();
          strIndex +=
              "Web depth:"
                  + deepUrls.get(tmpUrl)
                  + "   Filepath:"
                  + fPath
                  + "/web"
                  + allUrls.get(tmpUrl)
                  + ".htm"
                  + "   url:"
                  + tmpUrl
                  + "\n\n";
        }
        System.out.println(strIndex);
        try {
          PrintWriter pwIndex = new PrintWriter(new FileOutputStream("fileindex.txt"));
          pwIndex.println(strIndex);
          pwIndex.close();
        } catch (Exception e) {
          System.out.println("��������б�ʧ�ܣ�");
        }
        break;
      }
    }
  }
Пример #29
0
  /**
   * @param args
   * @throws Exception
   */
  public static void main(String[] args) {

    ExecutorService executor = Executors.newFixedThreadPool(10);
    // ThreadPoolExecutor executor = Executors.newFixedThreadPool(10);
    Callable<Long> worker =
        new Callable<Long>() {
          public Long call() throws Exception {
            long result = 0L;

            System.out.println("working...");
            while (true) {
              if (Thread.currentThread().isInterrupted()) {
                System.out.println("canceled...!");
                // Thread.currentThread().interrupt();
                break;
              }
              // Thread.sleep(1000); // simulates work
              result++;
              System.out.println("step " + result + "...");

              if (result == Long.MAX_VALUE) {
                break;
              }
            }

            return result;
          }
        };

    int startCount = Thread.activeCount();

    Future<Long> submit1 = executor.submit(worker);
    Future<Long> submit2 = executor.submit(worker);

    int middleCount = Thread.activeCount();

    try {
      Thread.sleep(500);
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    submit1.cancel(true);
    submit2.cancel(true);

    System.out.println("Canceled! " + submit1.isCancelled());
    System.out.println("Done! " + submit1.isDone());
    try {
      System.out.println("Get! " + submit1.get());
    } catch (CancellationException e1) {
      // TODO Auto-generated catch block
      // e1.printStackTrace();
      System.out.println("ERROR: " + e1.getMessage());
    } catch (Exception e1) {
      // TODO Auto-generated catch block
      e1.printStackTrace();
    }

    int lastCount = Thread.activeCount();

    System.out.println("Count: ");
    System.out.println(startCount);
    System.out.println(middleCount);
    System.out.println(lastCount);

    try {
      Thread.sleep(5000);
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    executor.shutdown();

    System.out.println("last count: " + Thread.activeCount());
  }
Пример #30
0
  private boolean forwardOrReturnResult(
      Message msg, RoutingContext[] lastRoutingContexts, final IDAddressPair[][] nextHopCands) {
    IDAddressPair lastHop = (IDAddressPair) msg.getSource();

    int routingID = ((AbstractRecRouteMessage) msg).routingID;
    final ID[] targets = ((AbstractRecRouteMessage) msg).target;
    RoutingContext[] routingContexts = ((AbstractRecRouteMessage) msg).cxt;
    int numResponsibleNodeCands = ((AbstractRecRouteMessage) msg).numRespNodeCands;
    IDAddressPair initiator = ((AbstractRecRouteMessage) msg).initiator;
    int ttl = ((AbstractRecRouteMessage) msg).ttl;
    RoutingHop[] route = ((AbstractRecRouteMessage) msg).route;
    IDAddressPair[] blackList = ((AbstractRecRouteMessage) msg).blackList;

    int callbackTag = -1;
    Serializable[][] callbackArgs = null;
    if (msg instanceof RecRouteInvokeMessage) {
      callbackTag = ((RecRouteInvokeMessage) msg).callbackTag;
      callbackArgs = ((RecRouteInvokeMessage) msg).callbackArgs;
    }
    // {
    // StringBuilder sb = new StringBuilder();
    // sb.append("forRetResult called:\n");
    // for (ID id: targets) sb.append(" " + id.toString(-1));
    // sb.append("\n");
    // sb.append("  on " + getSelfIDAddressPair().getAddress() + "\n");
    // sb.append("  msg: " + msg.getName() + "\n");
    // sb.append("  route:");
    // for (RoutingHop h: route) sb.append(" " + h.toString(-1));
    // sb.append("\n");
    // System.out.print(sb.toString());
    // }

    boolean ttlExpired = false;
    boolean succeed = true;
    Message newMsg;
    boolean[] forwarded = new boolean[targets.length];
    for (int i = 0; i < forwarded.length; i++) forwarded[i] = false;

    Set<IDAddressPair> blackListSet = new HashSet<IDAddressPair>();
    if (blackList != null) {
      for (IDAddressPair a : blackList) {
        blackListSet.add(a);
      }
    }

    // add this node itself to the resulting route
    RoutingHop[] lastRoute = route;
    route = new RoutingHop[lastRoute.length + 1];
    System.arraycopy(lastRoute, 0, route, 0, lastRoute.length);
    route[route.length - 1] = RoutingHop.newInstance(getSelfIDAddressPair());

    // TTL check
    if (ttl < 0) {
      StringBuilder sb = new StringBuilder();
      sb.append("TTL expired (target");
      for (ID t : targets) {
        sb.append(" ").append(t.toString(-1));
      }
      sb.append("):");
      for (RoutingHop h : route) {
        if (h == null) break;

        sb.append(" ");
        sb.append(h.getIDAddressPair().toString(-1));
      }

      logger.log(Level.WARNING, sb.toString(), new Throwable());

      ttlExpired = true;
      if (!(msg instanceof RecRouteJoinMessage)) { // allow joining node to succeed
        succeed = false;
      }
    }

    IDAddressPair[] nextHops = new IDAddressPair[targets.length];

    forward:
    while (true) {
      if (ttlExpired) break;

      do { // ... } while (false)
        Set<IDAddressPair> contactSet = new HashSet<IDAddressPair>();
        boolean allContactsAreNull = true;
        boolean aContactIsNull = false;

        for (int i = 0; i < targets.length; i++) {
          if (nextHopCands[i] == null || nextHopCands[i].length <= 0) {
            nextHops[i] = null;
          }

          nextHops[i] = nextHopCands[i][0];

          if (nextHops[i] == null) continue;

          if (blackListSet.contains(nextHops[i].getAddress())) {
            // next hop is in the black list
            nextHops[i] = null;
            System.arraycopy(nextHopCands[i], 1, nextHopCands[i], 0, nextHopCands[i].length - 1);
            continue;
          }

          if (msg instanceof RecRouteJoinMessage
              && nextHops[i].getAddress().equals(initiator.getAddress())) {
            // next hop is initiator of routing
            nextHops[i] = null;
            System.arraycopy(nextHopCands[i], 1, nextHopCands[i], 0, nextHopCands[i].length - 1);
            i--;

            logger.log(
                Level.WARNING,
                "Next hop is the joining node "
                    + initiator.getAddress()
                    + ". RoutingAlgorithm#touch() has been called too early?");

            continue;
          }

          // StringBuilder sb = new StringBuilder();
          // sb.append("judge to terminate[" + i + "]: " + targets[i].toString(-1) + "\n");
          // sb.append("  on:          " + this.getSelfIDAddressPair().toString(-1) + ":\n");
          // sb.append("  nextHop:     " + nextHops[i].toString(-1) + "\n");
          // sb.append("    " +
          // nextHops[i].getAddress().equals(this.getSelfIDAddressPair().getAddress()) + "\n");
          // sb.append("  context:     " + (routingContexts[i] != null ?
          // routingContexts[i].toString(-1) : "null") + "\n");
          // sb.append("  lastContext: " + (lastRoutingContexts[i] != null ?
          // lastRoutingContexts[i].toString(-1) : "null") + "\n");
          // if (routingContexts[i] != null && lastRoutingContexts[i] != null)
          // sb.append("    " + routingContexts[i].equals(lastRoutingContexts[i]) + "\n");
          if (nextHops[i].getAddress().equals(this.getSelfIDAddressPair().getAddress())
              && (routingContexts[i] == null
                  || routingContexts[i].equals(lastRoutingContexts[i]))) {
            // next hop is this node itself
            nextHops[i] = null; // terminates routing
            // sb.append("    terminate.\n");
          }
          // System.out.print(sb.toString());

          if (nextHops[i] != null) {
            contactSet.add(nextHops[i]);
            allContactsAreNull = false;
          } else {
            contactSet.add(null);
            aContactIsNull = true;
          }
        }

        if (allContactsAreNull) { // this node is the responsible node
          break forward;
        }

        // fork
        if (contactSet.size() > 1 || aContactIsNull) {
          // System.out.println("fork on " + getSelfIDAddressPair().getAddress());
          Set<Forwarder> forkedForwarder = new HashSet<Forwarder>();
          List<Integer> contactIndexList = new ArrayList<Integer>();

          for (IDAddressPair c : contactSet) {
            contactIndexList.clear();

            if (c == null) {
              for (int i = 0; i < targets.length; i++)
                if (nextHops[i] == null) contactIndexList.add(i);
            } else {
              for (int i = 0; i < targets.length; i++)
                if (c.equals(nextHops[i])) contactIndexList.add(i);
            }

            int nTgts = contactIndexList.size();
            final ID[] forkedTarget = new ID[nTgts];
            final RoutingContext[] forkedRoutingContext = new RoutingContext[nTgts];
            final RoutingContext[] forkedLastRoutingContext = new RoutingContext[nTgts];
            final IDAddressPair[][] forkedNextHopCands = new IDAddressPair[nTgts][];
            for (int i = 0; i < nTgts; i++) {
              int index = contactIndexList.get(i);
              forkedTarget[i] = targets[index];
              forkedRoutingContext[i] = routingContexts[index];
              forkedLastRoutingContext[i] = lastRoutingContexts[index];
              forkedNextHopCands[i] = nextHopCands[index];
            }
            Serializable[][] forkedCallbackArgs = null;
            if (callbackArgs != null) {
              forkedCallbackArgs = new Serializable[nTgts][];
              for (int i = 0; i < nTgts; i++) {
                int index = contactIndexList.get(i);
                forkedCallbackArgs[i] = callbackArgs[index];
              }
            }
            RoutingHop[] copiedRoute = new RoutingHop[route.length];
            System.arraycopy(route, 0, copiedRoute, 0, route.length);

            Forwarder f =
                new Forwarder(
                    RecursiveRoutingDriver.getRecRouteMessage(
                        msg.getClass(),
                        routingID,
                        forkedTarget,
                        forkedRoutingContext,
                        numResponsibleNodeCands,
                        initiator,
                        ttl,
                        copiedRoute,
                        blackList,
                        callbackTag,
                        forkedCallbackArgs),
                    forkedLastRoutingContext,
                    forkedNextHopCands);
            forkedForwarder.add(f);
          }

          // execute
          boolean ret = true;

          if (config.getUseThreadPool()) {
            Set<Future<Boolean>> fSet = new HashSet<Future<Boolean>>();
            Forwarder firstForwarder = null;

            ExecutorService ex =
                SingletonThreadPoolExecutors.getThreadPool(
                    ExecutorBlockingMode.CONCURRENT_REJECTING, Thread.currentThread().isDaemon());

            for (Forwarder forwarder : forkedForwarder) {
              if (firstForwarder == null) {
                firstForwarder = forwarder;
                continue;
              }

              try {
                Future<Boolean> f = ex.submit((Callable<Boolean>) forwarder);
                fSet.add(f);
              } catch (RejectedExecutionException e) {
                // invoke directly if rejected
                // Note that this is required to avoid deadlocks
                ret &= forwarder.call();
              }
            }

            ret &= firstForwarder.call(); // direct invocation

            for (Future<Boolean> f : fSet) {
              try {
                ret &= f.get();
              } catch (Exception e) {
                /*ignore*/
              }
            }
          } else {
            Set<Thread> tSet = new HashSet<Thread>();
            for (Runnable r : forkedForwarder) {
              Thread t = new Thread(r);
              t.setName("Forwarder");
              t.setDaemon(Thread.currentThread().isDaemon());
              tSet.add(t);
              t.start();
            }
            for (Thread t : tSet) {
              try {
                t.join();
              } catch (InterruptedException e) {
                /*ignore*/
              }
            }
            for (Forwarder f : forkedForwarder) {
              ret &= f.getResult();
            }
          }

          return ret;
        } // if (contactSet.size() > 1 || aContactIsNull) {	// fork

        // System.out.println("forward or reply on " + getSelfIDAddressPair().getAddress());
        IDAddressPair nextHop = nextHops[0];
        // assert: all nextHops[i].getIDAddressPair() is the same value
        // System.out.println("On " + getSelfIDAddressPair().getAddress() + ", nextHop: " +
        // nextHop);
        // System.out.println("  target: " + target[0]);

        // prepare a Message
        newMsg =
            RecursiveRoutingDriver.getRecRouteMessage(
                msg.getClass(),
                routingID,
                targets,
                routingContexts,
                numResponsibleNodeCands,
                initiator,
                ttl - 1,
                route,
                blackList,
                callbackTag,
                callbackArgs);

        try {
          Message ack = sender.sendAndReceive(nextHop.getAddress(), newMsg);
          // throws IOException
          // System.out.println("On " + getSelfIDAddressPair().getAddress() + ", forwarded " +
          // Tag.getNameByNumber(oldMsgTag) + " from " + getSelfIDAddressPair().getAddress() + " to
          // " + nextHop.getAddress());

          // fill ID of nextHop
          for (int i = 0; i < targets.length; i++) {
            if (nextHops[i].getID() == null) {
              // this is the case in the first iteration of joining
              nextHops[i].setID(((IDAddressPair) ack.getSource()).getID());
            }
          }

          // notify the routing algorithm
          if (algorithm != null) {
            algorithm.touch((IDAddressPair) ack.getSource());
          }

          if (ack instanceof RecAckMessage) {
            for (int i = 0; i < forwarded.length; i++) forwarded[i] = true;

            break forward;
          } else {
            logger.log(Level.SEVERE, "Received message is not REC_ACK.");
          }
        } catch (IOException e) {
          // System.out.println("  failed.");
          // sending failure and try the next node
          logger.log(
              Level.WARNING,
              "Failed to forward a request to "
                  + nextHop.getAddress()
                  + " on "
                  + getSelfIDAddressPair().getAddress(),
              e);
        }

        // fail to send/receive
        if (nextHop.getID() != null) { // nextHop.getID() is null when joining
          super.fail(nextHop);

          if (blackList != null) {
            IDAddressPair[] oldBlackList = blackList;
            blackList = new IDAddressPair[oldBlackList.length + 1];
            System.arraycopy(oldBlackList, 0, blackList, 0, oldBlackList.length);
          } else {
            blackList = new IDAddressPair[1];
          }
          blackList[blackList.length - 1] = nextHop;

          blackListSet.add(nextHop);

          logger.log(
              Level.INFO,
              nextHop.getAddress()
                  + " is added to blacklist on "
                  + this.getSelfIDAddressPair().getAddress());
        }
      } while (false);

      // shift nextHopCands[i]
      shiftNextHopCands:
      for (int i = 0; i < targets.length; i++) {
        if (nextHopCands[i] == null) continue;

        System.arraycopy(nextHopCands[i], 1, nextHopCands[i], 0, nextHopCands[i].length - 1);

        for (int j = 0; j < nextHopCands[i].length; j++) {
          if (nextHopCands[i][j] != null) continue shiftNextHopCands;
        }
        nextHopCands[i] = null;
      }
    } // forward: while (true)

    // notify the routing algorithm
    if (lastHop != null) algorithm.touch(lastHop); // source of message
    // this is an additional call to touch() compared with iterative lookup
    if (!this.getSelfIDAddressPair().equals(initiator))
      algorithm.touch(initiator); // initiator of message

    // message dependent processes
    Serializable[] callbackResult = new Serializable[targets.length];
    if (msg instanceof RecRouteInvokeMessage) {
      // invoke callbacks
      for (int i = 0; i < targets.length; i++) {
        callbackResult[i] =
            invokeCallbacks(targets[i], callbackTag, callbackArgs[i], lastHop, !forwarded[i]);
        if (callbackResult[i] != null) {
          logger.log(Level.INFO, "A callback returned non-null object: " + callbackResult[i]);
        }
      }
    } else if (msg instanceof RecRouteJoinMessage) {
      final IDAddressPair copiedJoiningNode = initiator;
      final IDAddressPair copiedLastHop = lastHop;
      final boolean[] copiedForwarded = new boolean[forwarded.length];
      System.arraycopy(forwarded, 0, copiedForwarded, 0, copiedForwarded.length);

      Runnable r =
          new Runnable() {
            public void run() {
              for (int i = 0; i < targets.length; i++) {
                algorithm.join(copiedJoiningNode, copiedLastHop, !copiedForwarded[i]);
              }
            }
          };

      try {
        if (config.getUseThreadPool()) {
          ExecutorService ex =
              SingletonThreadPoolExecutors.getThreadPool(
                  ExecutorBlockingMode.CONCURRENT_NON_BLOCKING, Thread.currentThread().isDaemon());
          ex.submit(r);
        } else {
          Thread t = new Thread(r);
          t.setName("Message type specific processes");
          t.setDaemon(Thread.currentThread().isDaemon());
          t.start();
        }
      } catch (OutOfMemoryError e) {
        logger.log(Level.SEVERE, "# of threads: " + Thread.activeCount(), e);

        //				Thread[] tarray = new Thread[Thread.activeCount()];
        //				Thread.enumerate(tarray);
        //				for (Thread t: tarray) System.out.println("Th: " + t.getName());
        //				System.out.flush();

        throw e;
      }
    }

    // reports the routing result to the initiator
    List<Integer> notForwardedIndexList = new ArrayList<Integer>();

    for (int i = 0; i < targets.length; i++) {
      if (!forwarded[i]) notForwardedIndexList.add(i);
    }

    if (!notForwardedIndexList.isEmpty()) {
      // get candidates for the responsible node
      ID[] partOfTarget = new ID[notForwardedIndexList.size()];
      RoutingResult[] partOfResult = new RoutingResult[notForwardedIndexList.size()];
      Serializable[] partOfCallbackResult = new Serializable[notForwardedIndexList.size()];

      for (int i = 0; i < notForwardedIndexList.size(); i++) {
        // target
        partOfTarget[i] = targets[notForwardedIndexList.get(i)];

        // routing result
        IDAddressPair[] respCands =
            algorithm.responsibleNodeCandidates(partOfTarget[i], numResponsibleNodeCands);

        if (msg instanceof RecRouteJoinMessage && initiator.equals(respCands[0])) {
          // remove initiator from the first place on the responsible node candidates list
          IDAddressPair[] orig = respCands;
          respCands = new IDAddressPair[respCands.length - 1];
          System.arraycopy(orig, 1, respCands, 0, respCands.length);
        }

        partOfResult[i] = new RoutingResult(route, respCands);

        // callback result
        partOfCallbackResult[i] = callbackResult[notForwardedIndexList.get(i)];
      }

      // this node is the destination, or failed to send
      Message repMsg =
          new RecResultMessage(
              routingID, succeed, partOfTarget, partOfResult, blackList, partOfCallbackResult);

      try {
        sender.send(initiator.getAddress(), repMsg);
        // System.out.println("replied from " + getSelfIDAddressPair().getAddress() + " to " +
        // initiator.getAddress()
        // + " for " + targets[0].toString(-1) + "..");

        for (int i : notForwardedIndexList) {
          forwarded[i] = true;
        }
      } catch (IOException e) {
        // sending failure
        logger.log(
            Level.WARNING,
            "Failed to report to the initiator: "
                + initiator.getAddress()
                + " on "
                + getSelfIDAddressPair().getAddress());

        super.fail(initiator);
      }
    } // if (!notForwardedIndexList.isEmpty())

    boolean ret = true;
    for (boolean b : forwarded) ret &= b;

    return ret;
  }