if (logger.isDebugEnabled()) {
                    logger.debug("Failed to select a job by {}", id, e);
                }
                lastException = e;
                ThreadUtil.sleep(RandomUtils.nextLong(500, 5000));
            }
        }
        logger.warn("Failed to select a job by {}", id, lastException);
        return OptionalEntity.empty();
    }

                }

                try ( InputStream is = f.getInputStream() ) {
                    for ( int i = 0; i < 8; i++ ) {
                        is.read();
                        Thread.sleep(soTimeout);
                    }
                }
            }
            finally {
                f.delete();
            }
        }
    }


    @SuppressWarnings ( "resource" )

                    if (expire > ctime)
                        delay = expire - ctime;
                }

if (delay > 2)
System.out.println("delay=" + delay);
                Thread.sleep(delay);
            } while (delay > 2);

            synchronized (t) {
                t.notifyAll();
            }
//System.out.println("numComplete=" + t.numComplete + ",numThreads=" + t.numThreads);

	return=$?
	if [ $return -eq 0 ]; then
		i=0
		timeout=10
		# Wait for the process to be properly started before exiting
		until { kill -0 `cat "$PID_FILE"`; } >/dev/null 2>&1
		do
			sleep 1
			i=$(($i + 1))
			if [ $i -gt $timeout ]; then
				log_end_msg 1
				exit 1
			fi
		done
	fi
	log_end_msg $return
	exit $return
	;;		
  stop)
	log_daemon_msg "Stopping $DESC"

            } catch (final NumberFormatException e) {
                logger.warn("Invalid read interval: {}", value);
            }
        }
        return readInterval;
    }

    protected void sleep(final long interval) {
        ThreadUtil.sleepQuietly(interval);
    }

    protected abstract void storeData(DataConfig dataConfig, IndexUpdateCallback callback, DataStoreParams paramMap,

                    // immediately
                    Thread.sleep(500 + RAND.nextInt(1000));
                }
            }
            catch ( InterruptedException e ) {
                log.debug("interrupted sleep in send", e);
            }

            if ( request != null ) {
                log.debug("Restting request");

            ThreadUtil.sleepQuietly(crawlerWaitMillis);
        }
    }

    public void delayByRules() {
        final long delay = getDelay();
        if (delay > 0) {
            ThreadUtil.sleep(delay);
        }
    }

    protected long getDelay() {
        if (ruleList.isEmpty()) {
            return 0;
        }
        final Calendar cal = getCurrentCal();

    protected long reloadInterval = 1000L;

    public void update() {
        CommonPoolUtil.execute(this::load);
    }

    protected void waitForNext() {
        if (reloadInterval > 0) {
            ThreadUtil.sleep(reloadInterval);
        }
    }

    public abstract int load();

    public void setReloadInterval(final long reloadInterval) {
        this.reloadInterval = reloadInterval;
    }

                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Waiting threads: {}", waitingThreadNames);
                }
                ThreadUtil.sleep(systemCpuCheckInterval);
                current = getSystemCpuPercent();
            }
        } finally {
            waitingThreadNames.remove(threadName);
        }
    }

                    crawlerStatusList.set(startedCrawlerNum, Constants.RUNNING);
                    startedCrawlerNum++;
                    activeCrawlerNum++;
                    ThreadUtil.sleep(crawlingExecutionInterval);
                    continue;
                }

                // check status
                for (int i = 0; i < startedCrawlerNum; i++) {