/**
     * Timestamp of the last time data store names were loaded from plugin files.
     * Used to implement a time-based cache refresh mechanism.
     * Volatile to ensure visibility across threads.
     */
    protected volatile long lastLoadedTime = 0;

    /**
     * Creates a new instance of DataStoreFactory.
     * This constructor initializes the factory for managing data store instances

    /**
     * The user agent string to use during crawling.
     */
    @Required
    @Size(max = 200)
    public String userAgent;

    /**
     * The number of crawler threads to use.
     */
    @Required
    @Min(value = 1)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer numOfThread;

    /**

                }
              });
      thread.start();
      // we want to wait until each thread is WAITING - one thread waiting inside CacheLoader.load
      // (in startSignal.await()), and the others waiting for that thread's result.
      while (thread.isAlive() && thread.getState() != Thread.State.WAITING) {
        Thread.yield();
      }
    }
    gettersStartedSignal.countDown();

     * Search criteria: target URLs.
     */
    public String urls;

    /**
     * Search criteria: user agent string.
     */
    public String userAgent;

    /**
     * Search criteria: number of threads.
     */
    public String numOfThread;

    /**
     * Search criteria: interval time.
     */
    public String intervalTime;

    /**
     * Search criteria: boost value.
     */

        logger.log(
            Level.INFO, "Failed to create a thread without inherited thread-local values", t);
      }
    }
    if (thread == null) {
      thread = new Thread((ThreadGroup) null, finalizer, threadName);
    }
    thread.setDaemon(true);

    try {
      if (inheritableThreadLocals != null) {
        inheritableThreadLocals.set(thread, null);
      }
    } catch (Throwable t) {
      logger.log(

   * {@linkplain Thread#getContextClassLoader() context class loader}. In simple environments, the
   * context class loader will find resources from the class path. In environments where different
   * threads can have different class loaders, for example app servers, the context class loader
   * will typically have been set to an appropriate loader for the current thread.
   *

    // 1. Subscribers to events posted on different threads can be interleaved with each other
    //    freely. (A event on one thread, B event on another could yield any of
    //    [a1, a2, a3, b1, b2], [a1, b2, a2, a3, b2], [a1, b2, b3, a2, a3], etc.)
    // 2. It's possible for subscribers to actually be dispatched to in a different order than they
    //    were added to the queue. It's easily possible for one thread to take the head of the

    /** Default interval time in milliseconds for web crawling. */
    public static final int DEFAULT_INTERVAL_TIME_FOR_WEB = 10000;

    /** Default number of threads for file system crawling. */
    public static final int DEFAULT_NUM_OF_THREAD_FOR_FS = 5;

    /** Default number of threads for web crawling. */
    public static final int DEFAULT_NUM_OF_THREAD_FOR_WEB = 1;

   * specific name, thread group or priority. The returned executor's {@link
   * Executor#execute(Runnable) execute()} method is called when this service is started, and should
   * return promptly.
   *
   * <p>The default implementation returns a new {@link Executor} that sets the name of its threads
   * to the string returned by {@link #serviceName}
   */

        urlFilter.init(sessionId);

        // Create multiple threads adding patterns
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                urlFilter.addInclude("https://site" + i + ".com/.*");
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {