Package org.nanonative.nano.core

Class NanoThreads<T extends NanoThreads<T>>

java.lang.Object
org.nanonative.nano.core.NanoBase<T>
org.nanonative.nano.core.NanoThreads<T>
Type Parameters:
T - The payload of the NanoThreads implementation, used for method chaining.
Direct Known Subclasses:
NanoServices
public abstract class NanoThreads<T extends NanoThreads<T>> extends NanoBase<T>
The abstract base class for Nano framework providing thread handling functionalities.

  • Field Details

  • Constructor Details

    • NanoThreads

      protected NanoThreads(Map<Object,Object> config, String... args)
      Initializes NanoThreads with configurations and command-line arguments.
      Parameters:
      config - Configuration parameters for the NanoThreads instance.
      args - Command-line arguments passed during the application start.

  • Method Details

    • run

      public T run(Supplier<Context> context, ExRunnable task, LocalTime atTime, DayOfWeek dow, BooleanSupplier until)
      Executes a task periodically, starting after an initial delay. nano.run(() -> myMethod(), LocalTime.of(7, 0, 0))
      Parameters:
      task - The task to execute.
      atTime - The time of hour/minute/second to start the task.
      dow - The day of the week to start the task.
      until - A BooleanSupplier indicating the termination condition. true stops the next execution.
      Returns:
      Self for chaining

    • runDaily

      public T runDaily(Supplier<Context> context, ExRunnable task, LocalTime atTime, BooleanSupplier until)
      Executes a task daily at the specified wall-clock time in the server's default time zone until the stop condition returns true.
      Parameters:
      context - the execution context supplier
      task - the task to execute
      atTime - the daily wall-clock time (hour, minute, second)
      until - stop condition; when true, cancels further runs
      Returns:
      self for chaining

    • runWeekly

      public T runWeekly(Supplier<Context> context, ExRunnable task, DayOfWeek dow, LocalTime atTime, BooleanSupplier until)
      Executes a task weekly at the given day of week and wall-clock time in the server's default time zone until the stop condition returns true.
      Parameters:
      context - the execution context supplier
      task - the task to execute
      dow - the day of the week
      atTime - the weekly wall-clock time (hour, minute, second)
      until - stop condition; when true, cancels further runs
      Returns:
      self for chaining

    • run

      public T run(Supplier<Context> context, ExRunnable task, LocalTime atTime, DayOfWeek dow, ZoneId zone, BooleanSupplier until)
      Core scheduling method for daily or weekly execution at a fixed wall-clock time. Uses ZonedDateTime in the given zone to account for daylight saving changes.
      Parameters:
      context - the execution context supplier
      task - the task to execute
      atTime - the wall-clock time (hour, minute, second)
      dow - optional day of week; if null, runs every day
      zone - the time zone (usually ZoneId.systemDefault())
      until - stop condition; when true, cancels further runs
      Returns:
      self for chaining

    • scheduleOnce

      protected void scheduleOnce(Supplier<Context> context, ExRunnable task, Scheduler scheduler, BooleanSupplier until, LocalTime atTime, DayOfWeek dow, ZoneId zone, ZonedDateTime planned)
      Internal recursive scheduler: schedules the given task once, then reschedules itself for the next occurrence.
      Parameters:
      context - the execution context supplier
      task - the task to execute
      scheduler - the scheduler executor
      until - stop condition; when true, cancels further runs
      atTime - the wall-clock time (hour, minute, second)
      dow - optional day of week; if null, runs every day
      zone - the time zone
      planned - the planned execution time

    • initialPlanned

      protected static ZonedDateTime initialPlanned(LocalTime atTime, DayOfWeek dow, ZoneId zone)
      Calculates the first execution time after now for the given wall-clock time and day of week.
      Parameters:
      atTime - the wall-clock time
      dow - optional day of week; if null, runs daily
      zone - the time zone
      Returns:
      the first valid planned execution time

    • nextPlanned

      protected static ZonedDateTime nextPlanned(ZonedDateTime prevPlanned, LocalTime atTime, DayOfWeek dow, ZoneId zone)
      Calculates the next execution time after a previous planned run.
      Parameters:
      prevPlanned - the previous planned run time
      atTime - the wall-clock time
      dow - optional day of week; if null, runs daily
      zone - the time zone
      Returns:
      the next planned execution time

    • resolveWallTime

      protected static ZonedDateTime resolveWallTime(LocalDate date, LocalTime time, ZoneId zone)
      DST-safe wall time: pushes through gaps, picks the earlier offset in overlaps.

    • schedulers

      public Set<ScheduledExecutorService> schedulers()
      Provides an unmodifiable set of ScheduledExecutorService.
      Returns:
      An unmodifiable set of ScheduledExecutorService instances.

    • run

      public T run(Supplier<Context> context, ExRunnable task, long delay, TimeUnit timeUnit)
      Executes a task asynchronously after a specified delay.
      Parameters:
      task - The task to execute.
      delay - The delay before executing the task.
      timeUnit - The time unit of the delay parameter.
      Returns:
      Self for chaining

    • run

      public T run(Supplier<Context> context, ExRunnable task, long delay, long period, TimeUnit unit, BooleanSupplier until)
      Executes a task periodically, starting after an initial delay.
      Parameters:
      task - The task to execute.
      delay - The initial delay before executing the task.
      period - The period between successive task executions.
      unit - The time unit of the initialDelay and period parameters.
      until - A BooleanSupplier indicating the termination condition. true stops the next execution.
      Returns:
      Self for chaining

    • asyncFromPool

      protected Scheduler asyncFromPool(Supplier<Context> context)
      Creates a Scheduler from the thread pool.
      Returns:
      The newly created Scheduler.

    • shutdownThreads

      protected void shutdownThreads()
      Shuts down all threads and scheduled executors gracefully.

    • shutdownExecutors

      protected void shutdownExecutors(long timeoutMs, ExecutorService... executorServices)
      Shuts down executors and handles timeout for forced termination.
      Parameters:
      timeoutMs - The maximum time to wait for executor termination.
      executorServices - An array of ExecutorService instances to shut down.

    • removeScheduler

      protected void removeScheduler(ExecutorService executorService)
      Removes a scheduler from the set of managed schedulers.
      Parameters:
      executorService - The ExecutorService to remove from the scheduler set.

    • kill

      protected void kill(ExecutorService executorService, long timeoutMs) throws InterruptedException
      Forces shutdown of an ExecutorService if it doesn't terminate within the specified timeout.
      Parameters:
      executorService - The executor service to shut down.
      timeoutMs - The maximum time to wait for termination.
      Throws:
      InterruptedException - if interrupted while waiting.

    • executeScheduler

      protected void executeScheduler(Supplier<Context> context, ExRunnable task, Scheduler scheduler, boolean periodically)
      Executes the task.
      Parameters:
      context - the context
      task - the task
      scheduler - the scheduler
      periodically - the periodically