首页 > 代码库 > Floodlight controller 线程池模型

Floodlight controller 线程池模型

2024-07-13 10:00:53   219人阅读



     官方文档对于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. 所以只要对并发编程有点基础，就很容易理解，它实现了俩接口：1）IThreadPoolService规范的是得到ScheduledExecutorService的方法，2）IFloodlightModule则是将实现类作为模块来管理（默认启动），好处是方便其他模块很容易的指明依赖。看代码就很容易明白。

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
     }
}





Floodlight controller 线程池模型


联系
我们