官方文档对于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
}
}
版权声明：本文博客原创文章，博客，未经同意，不得转载。