*/
public class ServiceLifecycle implements AsyncStoppable {
    private enum State {RUNNING, STOPPING, STOPPED}

    private final String displayName;
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private final Map<Thread, Integer> usages = new HashMap<>();
    private State state = State.RUNNING;

    public ServiceLifecycle(String displayName) {

    private static final Logger logger = LoggerFactory.getLogger(LhaExtractor.class);

    protected long maxContentSize = -1;

    @Override
    public ExtractData getText(final InputStream in, final Map<String, String> params) {
        if (in == null) {
            throw new CrawlerSystemException("The inputstream is null.");
        }

        final MimeTypeHelper mimeTypeHelper = getMimeTypeHelper();

            ftpClient.doGet("ftp://localhost:" + FTP_PORT + "/");
            fail();
        } catch (final ChildUrlsException e) {
            final Set<RequestData> urlSet = e.getChildUrlList();
            assertEquals(5, urlSet.size());
            for (final RequestData requestData : urlSet.toArray(new RequestData[urlSet.size()])) {
                String url = requestData.getUrl();

    private final Lock lock;
    private final Condition condition;
    private final List<ResourceHandlerWrapper> received = new ArrayList<>();
    private final List<ResourceHandlerWrapper> released = new ArrayList<>();
    private final LinkedList<ResourceHandlerWrapper> notReleased = new LinkedList<>();
    private final List<ResourceHandlerWrapper> notReceived = new ArrayList<>();

        }

    }

    protected void storeChildUrls(final Set<RequestData> childUrlList, final String url, final int depth) {
        if (crawlerContext.getMaxDepth() >= 0 && depth > crawlerContext.getMaxDepth()) {
            return;
        }

        // add url and filter
        final Set<String> urlSet = new HashSet<>();

    protected void process(final LaJobRuntime runtime) {
        if (!runtime.getParameterMap().containsKey(Constants.SCHEDULED_JOB)) {
            logger.warn("{} is empty.", Constants.SCHEDULED_JOB);
            return;
        }
        runtime.stopIfNeeds();

        final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
        final JobManager jobManager = ComponentUtil.getJobManager();

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultFileLockManager.class);
    public static final int DEFAULT_LOCK_TIMEOUT = 60000;

    private final Set<File> lockedFiles = new CopyOnWriteArraySet<>();
    private final ProcessMetaDataProvider metaDataProvider;
    private final int lockTimeoutMs;
    private final LongSupplier generator;
    private final FileLockContentionHandler fileLockContentionHandler;

        final String value = "Mon, 01 Jun 2009 21:02:45 GMT";
        final Date date = httpClient.parseLastModified(value);
        assertNotNull(date);
    }

    public void test_processRobotsTxt() {
        final CrawlerWebServer server = new CrawlerWebServer(7070);
        server.start();

        final String url = "http://localhost:7070/hoge.html";
        try {

 * This can be used to implement guaranteed delivery mechanisms, where proper interrupt handling is up to the delegate.
 */
public final class InterruptibleRunnable implements Runnable {
    private final Lock stateLock = new ReentrantLock();
    private final Runnable delegate;
    private boolean interrupted;
    private Thread thread;

    public InterruptibleRunnable(Runnable delegate) {

 *
 * <pre>{@code
 * public class SafeBox<V> {
 *   private V value;
 *   private final ReentrantLock lock = new ReentrantLock();
 *   private final Condition valuePresent = lock.newCondition();
 *   private final Condition valueAbsent = lock.newCondition();
 *
 *   public V get() throws InterruptedException {
 *     lock.lock();
 *     try {