Floodlight controller 线程池模型

     官方文档对于ThreadPool的描写叙述是：ThreadPool is a Floodlight module wrapper for a Java's ScheduledExecutorService.  It can be used to
have threads be run at specific times or periodically. 所以仅仅要对并发编程有点基础，就非常easy理解。它实现了俩接口：1）IThreadPoolService规范的是得到ScheduledExecutorService的方法，2）IFloodlightModule则是将实现类作为模块来管理（默认启动）。优点是方便其它模块非常easy的指明依赖。看代码就非常easy明确。

public interface IThreadPoolService extends IFloodlightService
{

    /**

     * Get the master scheduled thread pool executor maintained by the

     * ThreadPool provider.  This can be used by other modules as a centralized

     * way to schedule tasks.

     * @return

     */

    public ScheduledExecutorService
getScheduledExecutor();

}

---

public interface IFloodlightModule
{

     

      /**

      * Return the list of interfaces that this module implements.

      * All interfaces must inherit IFloodlightService

      * @return

      */

     

      public Collection<Class<? extends IFloodlightService>>
getModuleServices();

     

      /**

      * Instantiate (as needed) and return objects that implement each

      * of the services exported by this module.  The map returned maps

      * the implemented service to the object.  The object could be the

      * same object or different objects for different exported services.

      * @return The
map from service interface class to service implementation

      */

      public Map<Class<? extends IFloodlightService>,

                IFloodlightService> getServiceImpls();

     

      /**

      * Get a list of Modules that this module depends on.  The module system

      * will ensure that each these dependencies is resolved before the

      * subsequent calls to init().

      * @return The
Collection of IFloodlightServices that this module depends

      *         on.

      */

     

      public Collection<Class<? extends IFloodlightService>>
getModuleDependencies();

     

      /**

      * This is a hook for each module to do its <em> internal</em> initialization,

      * e.g., call setService(context.getService("Service"))

      *

      * All module dependencies are resolved when this is called, but not every module

      * is initialized.

      *

      * @param context

      * @throws FloodlightModuleException

      */

     

      void init(FloodlightModuleContext
context) throws FloodlightModuleException;

     

      /**

      * This is a hook for each module to do its <em> external</em> initializations,

      * e.g., register for callbacks or
query for state in other modules

      *

      * It is expected that this function will not block and that modules that want

      * non - event
driven CPU will spawn their own threads.

      *

      * @param context

      */

     

      void startUp(FloodlightModuleContext
context);

}

---

public class ThreadPool implements IThreadPoolService,
IFloodlightModule {

      protected ScheduledExecutorService executor = null ;

      // IThreadPoolService

      @Override

      public ScheduledExecutorService
getScheduledExecutor() {

           return executor ;

     }

      // IFloodlightModule

      @Override

      public Collection<Class<? extends IFloodlightService>>
getModuleServices() {

          Collection<Class<? extends IFloodlightService>>
l = new ArrayList<Class<?

extends IFloodlightService>>();

          l.add(IThreadPoolService. class );

           return l;

     }

      @Override

      public Map<Class<?

extends IFloodlightService>,
IFloodlightService> getServiceImpls() {

          Map<Class<? extends IFloodlightService>,
IFloodlightService> m = new HashMap<Class<?

extends IFloodlightService>,
IFloodlightService>();

          m.put(IThreadPoolService. class , this );

           // We are the class that implements the
service

           return m;

     }

      @Override

      public Collection<Class<? extends IFloodlightService>>
getModuleDependencies() {

           // No dependencies

           return null ;

     }

      @Override

      public void init(FloodlightModuleContext
context)

               throws FloodlightModuleException
{

           executor =
Executors. newScheduledThreadPool(15);

           // parameter - the number of threads to
keep in the pool, even if they are idle.

     }

      @Override

      public void startUp(FloodlightModuleContext
context) {

           // no-op

     }

}

版权声明：本文博客原创文章，博客，未经同意，不得转载。