How to use

notifyThreadReleased

method

in

org.glassfish.grizzly.threadpool.ProbeNotifier

/**
 * Method is called by {@link Worker}, when it's completing
 * {@link Worker#run()} method execution, which in most cases means,
 * that ThreadPool's thread will be released. This method is called from
 * {@link Worker}'s thread.
 *
 * @param worker
 */
protected void onWorkerExit(Worker worker) {
  synchronized (stateLock) {
    workers.remove(worker);
    if (delayedQueue != null) {
      delayedQueue.remove(worker);
    }
    if (workers.isEmpty()) {
      // notify awaitTermination threads
      stateLock.notifyAll();
    }
  }
  ProbeNotifier.notifyThreadReleased(this, worker.t);
}

/**
 * Method is called by {@link Worker}, when it's completing
 * {@link Worker#run()} method execution, which in most cases means,
 * that ThreadPool's thread will be released. This method is called from
 * {@link Worker}'s thread.
 *
 * @param worker
 */
protected void onWorkerExit(Worker worker) {
  synchronized (stateLock) {
    workers.remove(worker);
    if (delayedQueue != null) {
      delayedQueue.remove(worker);
    }
    if (workers.isEmpty()) {
      // notify awaitTermination threads
      stateLock.notifyAll();
    }
  }
  ProbeNotifier.notifyThreadReleased(this, worker.t);
}

/**
 * Method is called by {@link Worker}, when it's completing
 * {@link Worker#run()} method execution, which in most cases means,
 * that ThreadPool's thread will be released. This method is called from
 * {@link Worker}'s thread.
 *
 * @param worker
 */
protected void onWorkerExit(Worker worker) {
  synchronized (stateLock) {
    workers.remove(worker);
    if (delayedQueue != null) {
      delayedQueue.remove(worker);
    }
    if (workers.isEmpty()) {
      // notify awaitTermination threads
      stateLock.notifyAll();
    }
  }
  ProbeNotifier.notifyThreadReleased(this, worker.t);
}

/**
 * Method is called by {@link Worker}, when it's completing
 * {@link Worker#run()} method execution, which in most cases means,
 * that ThreadPool's thread will be released. This method is called from
 * {@link Worker}'s thread.
 *
 * @param worker
 */
protected void onWorkerExit(Worker worker) {
  synchronized (stateLock) {
    workers.remove(worker);
    if (delayedQueue != null) {
      delayedQueue.remove(worker);
    }
    if (workers.isEmpty()) {
      // notify awaitTermination threads
      stateLock.notifyAll();
    }
  }
  ProbeNotifier.notifyThreadReleased(this, worker.t);
}

/**
 * Method is called by {@link Worker}, when it's completing
 * {@link Worker#run()} method execution, which in most cases means,
 * that ThreadPool's thread will be released. This method is called from
 * {@link Worker}'s thread.
 *
 * @param worker
 */
protected void onWorkerExit(Worker worker) {
  synchronized (stateLock) {
    workers.remove(worker);
    if (delayedQueue != null) {
      delayedQueue.remove(worker);
    }
    if (workers.isEmpty()) {
      // notify awaitTermination threads
      stateLock.notifyAll();
    }
  }
  ProbeNotifier.notifyThreadReleased(this, worker.t);
}

/**
 * Method is called by {@link Worker}, when it's completing
 * {@link Worker#run()} method execution, which in most cases means,
 * that ThreadPool's thread will be released. This method is called from
 * {@link Worker}'s thread.
 *
 * @param worker
 */
protected void onWorkerExit(Worker worker) {
  synchronized (stateLock) {
    workers.remove(worker);
    if (delayedQueue != null) {
      delayedQueue.remove(worker);
    }
    if (workers.isEmpty()) {
      // notify awaitTermination threads
      stateLock.notifyAll();
    }
  }
  ProbeNotifier.notifyThreadReleased(this, worker.t);
}

/**
 * Method is called by {@link Worker}, when it's completing
 * {@link Worker#run()} method execution, which in most cases means,
 * that ThreadPool's thread will be released. This method is called from
 * {@link Worker}'s thread.
 *
 * @param worker
 */
protected void onWorkerExit(Worker worker) {
  synchronized (stateLock) {
    workers.remove(worker);
    if (delayedQueue != null) {
      delayedQueue.remove(worker);
    }
    if (workers.isEmpty()) {
      // notify awaitTermination threads
      stateLock.notifyAll();
    }
  }
  ProbeNotifier.notifyThreadReleased(this, worker.t);
}

/**
 * Method is called by {@link Worker}, when it's completing
 * {@link Worker#run()} method execution, which in most cases means,
 * that ThreadPool's thread will be released. This method is called from
 * {@link Worker}'s thread.
 *
 * @param worker
 */
protected void onWorkerExit(Worker worker) {
  synchronized (stateLock) {
    workers.remove(worker);
    if (delayedQueue != null) {
      delayedQueue.remove(worker);
    }
    if (workers.isEmpty()) {
      // notify awaitTermination threads
      stateLock.notifyAll();
    }
  }
  ProbeNotifier.notifyThreadReleased(this, worker.t);
}

/**
 * Method is called by {@link Worker}, when it's completing
 * {@link Worker#run()} method execution, which in most cases means,
 * that ThreadPool's thread will be released. This method is called from
 * {@link Worker}'s thread.
 *
 * @param worker
 */
protected void onWorkerExit(Worker worker) {
  synchronized (stateLock) {
    workers.remove(worker);
    if (delayedQueue != null) {
      delayedQueue.remove(worker);
    }
    if (workers.isEmpty()) {
      // notify awaitTermination threads
      stateLock.notifyAll();
    }
  }
  ProbeNotifier.notifyThreadReleased(this, worker.t);
}

/**
 * Method is called by {@link Worker}, when it's completing
 * {@link Worker#run()} method execution, which in most cases means,
 * that ThreadPool's thread will be released. This method is called from
 * {@link Worker}'s thread.
 *
 * @param worker
 */
protected void onWorkerExit(Worker worker) {
  synchronized (stateLock) {
    workers.remove(worker);
    if (delayedQueue != null) {
      delayedQueue.remove(worker);
    }
    if (workers.isEmpty()) {
      // notify awaitTermination threads
      stateLock.notifyAll();
    }
  }
  ProbeNotifier.notifyThreadReleased(this, worker.t);
}

/**
 * Method is called by {@link Worker}, when it's completing
 * {@link Worker#run()} method execution, which in most cases means,
 * that ThreadPool's thread will be released. This method is called from
 * {@link Worker}'s thread.
 *
 * @param worker
 */
protected void onWorkerExit(Worker worker) {
  synchronized (stateLock) {
    workers.remove(worker);
    if (delayedQueue != null) {
      delayedQueue.remove(worker);
    }
    if (workers.isEmpty()) {
      // notify awaitTermination threads
      stateLock.notifyAll();
    }
  }
  ProbeNotifier.notifyThreadReleased(this, worker.t);
}

/**
 * Method is called by {@link Worker}, when it's completing
 * {@link Worker#run()} method execution, which in most cases means,
 * that ThreadPool's thread will be released. This method is called from
 * {@link Worker}'s thread.
 *
 * @param worker
 */
protected void onWorkerExit(Worker worker) {
  synchronized (stateLock) {
    workers.remove(worker);
    if (delayedQueue != null) {
      delayedQueue.remove(worker);
    }
    if (workers.isEmpty()) {
      // notify awaitTermination threads
      stateLock.notifyAll();
    }
  }
  ProbeNotifier.notifyThreadReleased(this, worker.t);
}