Java KeyDistributedExecutor类代码示例

import org.threadly.concurrent.wrapper.KeyDistributedExecutor; //导入依赖的package包/类
/**
 * <p>Creates a ThreadedSocketExecuter with different max task cycle and Selector Thread defaults.</p> 
 * 
 * @param scheduler the {@link SubmitterScheduler} to be used for client/server callbacks.
 * @param maxTasksPerCycle the max number of tasks to run on a clients thread before returning the thread back to the pool.
 * @param numberOfSelectors the number of selector threads to run.  Default is core/2.
 */
public ThreadedSocketExecuter(final SubmitterScheduler scheduler, final int maxTasksPerCycle, final int numberOfSelectors) {
  super(scheduler);
  int ps = -1;
  if(numberOfSelectors == -1) {
     ps = Runtime.getRuntime().availableProcessors()/2;
  } else {
    ps = numberOfSelectors;
  }
  clientSelectors = new SelectorThread[ps];
  clientDistributer = new KeyDistributedExecutor(schedulerPool, maxTasksPerCycle);
  this.selectors = ps;
}
 

import org.threadly.concurrent.wrapper.KeyDistributedExecutor; //导入依赖的package包/类
public KeyDistributedSchedulerExecuteUnfairExecutorBenchmark(int threadRunTime, int poolSize) {
  super(threadRunTime);
  
  originalExecutor = new UnfairExecutor(poolSize);
  keyScheduler = new KeyDistributedExecutor(originalExecutor);
  scheduler = new ExecutorSchedulerAdapter((task) -> keyScheduler.getExecutorForKey(new Object())
                                                                 .execute(task));
}
 

import org.threadly.concurrent.wrapper.KeyDistributedExecutor; //导入依赖的package包/类
public KeyDistributedExecutorUniqueKeyUnfairExecutorBenchmark(int submitterQty) {
  this.submitterQty = submitterQty;
  scheduler = new UnfairExecutor((submitterQty * 2) + 1);
  distributor = new KeyDistributedExecutor(scheduler);
  lastRunnable = new AtomicReferenceArray<DistributorRunnable>(submitterQty);
}
 

import org.threadly.concurrent.wrapper.KeyDistributedExecutor; //导入依赖的package包/类
/**
 * Constructs a new {@link DefaultExecutorListenerHelper} that will handle listeners with the 
 * provided interface.  The provided class MUST be an interface.  If any listeners are not 
 * provided an executor, they will execute on the provided executor.
 * 
 * @param listenerInterface Interface that listeners need to implement
 * @param executor Executor to execute listeners which were not provided one by default
 */
public DefaultExecutorListenerHelper(Class<? super T> listenerInterface, Executor executor) {
  super(listenerInterface);
  
  taskDistributor = new KeyDistributedExecutor(executor);
}
 

import org.threadly.concurrent.wrapper.KeyDistributedExecutor; //导入依赖的package包/类
/**
 * Constructs a new {@link DefaultExecutorRunnableListenerHelper}.  If any listeners are not 
 * provided an executor, they will execute on the provided executor.
 * 
 * @param callListenersOnce {@code true} if listeners should only be called once
 * @param executor {@link Executor} to execute listeners which were not provided one by default
 */
public DefaultExecutorRunnableListenerHelper(boolean callListenersOnce, Executor executor) {
  super(callListenersOnce);
  
  taskDistributor = new KeyDistributedExecutor(executor);
}