Package aQute.libg.forker

Class Forker<T>

  • Type Parameters:
    T - 
    public class Forker<T>
extends java.lang.Object
    A Forker is good in parallel scheduling tasks with dependencies. You can add tasks with doWhen(Collection, Object, Runnable). The collection is the list of dependencies, the object is the target, and the runnable is run to update the target. The runnable will only run when all its dependencies have ran their associated runnable.

    • Nested Class Summary

      Nested Classes 
      Modifier and Type Class Description
      (package private) class  Forker.Job
      Helper class to model a Job

    • Field Summary

      Fields 
      Modifier and Type Field Description
      (package private) java.util.concurrent.atomic.AtomicBoolean canceled  
      private int count  
      (package private) java.util.Set<Forker.Job> executing  
      (package private) java.util.concurrent.Executor executor  
      (package private) java.util.Map<T,​Forker.Job> waiting  

    • Constructor Summary

      Constructors 
      Constructor Description
      Forker()
      Constructor
      Forker​(java.util.concurrent.Executor executor)
      Constructor

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void cancel​(long ms)
      Cancel the forker.
      private void check()  
      (package private) void done​(Forker.Job done)
      Called when the target has ran by the Job.
      void doWhen​(java.util.Collection<? extends T> dependencies, T target, java.lang.Runnable runnable)
      Schedule a job for execution when the dependencies are done of target are done.
      int getCount()  
      private void schedule()  
      void start​(long ms)  
      void sync​(long ms)  

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Field Detail

      • executor

        final java.util.concurrent.Executor executor

      • waiting

        final java.util.Map<T,​Forker.Job> waiting

      • executing

        final java.util.Set<Forker.Job> executing

      • canceled

        final java.util.concurrent.atomic.AtomicBoolean canceled

      • count

        private int count

    • Constructor Detail

      • Forker

        public Forker​(java.util.concurrent.Executor executor)
        Constructor
        Parameters:
        executor -

      • Forker

        public Forker()
        Constructor

    • Method Detail

      • doWhen

        public void doWhen​(java.util.Collection<? extends T> dependencies,
                   T target,
                   java.lang.Runnable runnable)
        Schedule a job for execution when the dependencies are done of target are done.
        Parameters:
        dependencies - the dependencies that must have run
        target - the target, is removed from all the dependencies when it ran
        runnable - the runnable to run

      • start

        public void start​(long ms)
           throws java.lang.InterruptedException
        Throws:
        java.lang.InterruptedException

      • check

        private void check()

      • sync

        public void sync​(long ms)
          throws java.lang.InterruptedException
        Throws:
        java.lang.InterruptedException

      • schedule

        private void schedule()

      • done

        void done​(Forker.Job done)
        Called when the target has ran by the Job.
        Parameters:
        done -

      • cancel

        public void cancel​(long ms)
            throws java.lang.InterruptedException
        Cancel the forker.
        Throws:
        java.lang.InterruptedException

      • getCount

        public int getCount()