Java PriorityScheduler.prestartAllThreads方法代码示例

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
@Test
public void getWithTimeoutResultTest() throws InterruptedException, 
                                              ExecutionException, 
                                              TimeoutException {
  final String testResult = StringUtils.makeRandomString(5);
  
  PriorityScheduler scheduler = new StrictPriorityScheduler(1);
  try {
    scheduler.prestartAllThreads();
    scheduler.schedule(new Runnable() {
      @Override
      public void run() {
        slf.setResult(testResult);
      }
    }, DELAY_TIME);
    
    assertTrue(slf.get(DELAY_TIME + (SLOW_MACHINE ? 2000 : 1000), TimeUnit.MILLISECONDS) == testResult);
  } finally {
    scheduler.shutdownNow();
  }
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public KeyDistributedExecutorUniqueKeyBenchmark(int submitterQty) {
  this.submitterQty = submitterQty;
  scheduler = new PriorityScheduler(submitterQty * 2);
  scheduler.prestartAllThreads();
  distributor = new KeyDistributedScheduler(scheduler);
  lastRunnable = new AtomicReferenceArray<DistributorRunnable>(submitterQty);
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public KeyDistributedSchedulerRecurringBenchmark(int threadRunTime, int poolSize) {
  super(threadRunTime);
  
  originalExecutor = new PriorityScheduler(poolSize, TaskPriority.High, 0);
  originalExecutor.prestartAllThreads();
  keyScheduler = new KeyDistributedScheduler(originalExecutor);
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public KeyedLimiterRecurringBenchmark(int threadRunTime, int poolSize) {
  super(threadRunTime);
  
  originalExecutor = new PriorityScheduler(poolSize, TaskPriority.High, 0);
  originalExecutor.prestartAllThreads();
  keyLimiter = new KeyedSubmitterSchedulerLimiter(originalExecutor, Integer.MAX_VALUE);
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public KeyedLimiterScheduleBenchmark(int threadRunTime, int poolSize) {
  super(threadRunTime);
  
  originalExecutor = new PriorityScheduler(poolSize, TaskPriority.High, 0);
  originalExecutor.prestartAllThreads();
  keyLimiter = new KeyedSubmitterSchedulerLimiter(originalExecutor, Integer.MAX_VALUE);
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public KeyDistributedExecutorManySubmitterBenchmark(int submitterQty) {
  executor = new PriorityScheduler(submitterQty * 2);
  executor.prestartAllThreads();
  distributor = new KeyDistributedScheduler(executor);
  this.submitterQty = submitterQty;
  
  lastRunnable = 
      new AtomicReferenceArray<DistributorRunnable>(submitterQty);
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public PrioritySchedulerScheduleBenchmark(int threadRunTime, int poolSize) {
  super(threadRunTime);
  
  // change to StrictPriorityScheduler for testing logic (and then run inside eclipse)
  scheduler = new PriorityScheduler(poolSize, TaskPriority.High, 0);
  scheduler.prestartAllThreads();
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public SubmitterSchedulerLimiterRecurringBenchmark(int threadRunTime, int poolSize) {
  super(threadRunTime);
  
  originalExecutor = new PriorityScheduler(poolSize, TaskPriority.High, 0);
  originalExecutor.prestartAllThreads();
  executor = new SubmitterSchedulerLimiter(originalExecutor, Integer.MAX_VALUE);
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public PrioritySchedulerExecuteBenchmark(int threadRunTime, int poolSize) {
  super(threadRunTime);
  
  // change to StrictPriorityScheduler for testing logic (and then run inside eclipse)
  scheduler = new PriorityScheduler(poolSize, TaskPriority.High, 0);
  scheduler.prestartAllThreads();
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public SubmitterSchedulerLimiterScheduleBenchmark(int threadRunTime, int poolSize) {
  super(threadRunTime);
  
  originalExecutor = new PriorityScheduler(poolSize, TaskPriority.High, 0);
  originalExecutor.prestartAllThreads();
  executor = new SubmitterSchedulerLimiter(originalExecutor, Integer.MAX_VALUE);
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public KeyDistributedSchedulerExecuteBenchmark(int threadRunTime, int poolSize) {
  super(threadRunTime);
  
  originalExecutor = new PriorityScheduler(poolSize, TaskPriority.High, 0);
  originalExecutor.prestartAllThreads();
  keyScheduler = new KeyDistributedScheduler(originalExecutor);
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public KeyDistributedSchedulerScheduleBenchmark(int threadRunTime, int poolSize) {
  super(threadRunTime);
  
  originalExecutor = new PriorityScheduler(poolSize, TaskPriority.High, 0);
  originalExecutor.prestartAllThreads();
  keyScheduler = new KeyDistributedScheduler(originalExecutor);
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public PrioritySchedulerRecurringBenchmark(int threadRunTime, int poolSize) {
  super(threadRunTime);
  
  // change to StrictPriorityScheduler for testing logic (and then run inside eclipse)
  scheduler = new PriorityScheduler(poolSize, TaskPriority.High, 0);
  scheduler.prestartAllThreads();
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public SubmitterSchedulerLimiterExecuteBenchmark(int threadRunTime, int poolSize) {
  super(threadRunTime);
  
  originalExecutor = new PriorityScheduler(poolSize, TaskPriority.High, 0);
  originalExecutor.prestartAllThreads();
  executor = new SubmitterSchedulerLimiter(originalExecutor, Integer.MAX_VALUE);
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public KeyedLimiterExecuteBenchmark(int threadRunTime, int poolSize) {
  super(threadRunTime);
  
  originalExecutor = new PriorityScheduler(poolSize, TaskPriority.High, 0);
  originalExecutor.prestartAllThreads();
  keyLimiter = new KeyedSubmitterSchedulerLimiter(originalExecutor, Integer.MAX_VALUE);
}