Java PriorityScheduler.shutdownNow方法代码示例

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

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包/类
@Test
public void listenableFutureTest() {
  PriorityScheduler executor = new StrictPriorityScheduler(1);
  try {
    PrioritySchedulerServiceWrapper wrapper = new PrioritySchedulerServiceWrapper(executor);
    TestRunnable futureListener = new TestRunnable();
    ListenableFuture<?> future = wrapper.submit(DoNothingRunnable.instance());
    future.addListener(futureListener);
    
    futureListener.blockTillFinished(); // throws exception if never called
  } finally {
    executor.shutdownNow();
  }
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
@Test
public void limitTest() throws InterruptedException, ExecutionException {
  int rateLimit = 100;
  final AtomicInteger ranPermits = new AtomicInteger();
  PriorityScheduler pse = new StrictPriorityScheduler(32);
  try {
    RateLimiterExecutor rls = new RateLimiterExecutor(pse, rateLimit);
    ListenableFuture<?> lastFuture = null;
    double startTime = Clock.accurateForwardProgressingMillis();
    boolean flip = true;
    for (int i = 0; i < TEST_QTY * 2; i++) {
      final int permit = 5;
      if (flip) {
        lastFuture = rls.submit(permit, new Runnable() {
          @Override
          public void run() {
            ranPermits.addAndGet(permit);
          }
        });
        flip = false;
      } else {
        lastFuture = rls.submit(permit, new Callable<Void>() {
          @Override
          public Void call() {
            ranPermits.addAndGet(permit);
            return null;
          }
        });
        flip = true;
      }
    }
    lastFuture.get();
    long endTime = Clock.accurateForwardProgressingMillis();
    double actualLimit = ranPermits.get() / ((endTime - startTime) / 1000);
    
    assertEquals(rateLimit, actualLimit, SLOW_MACHINE ? 75 : 50);
  } finally {
    pse.shutdownNow();
  }
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
@Test
public void isShutdownTest() {
  PriorityScheduler executor = new StrictPriorityScheduler(1);
  try {
    SchedulerServiceLimiter limiter = new SchedulerServiceLimiter(executor, 1);
    
    assertFalse(limiter.isShutdown());
    executor.shutdownNow();
    assertTrue(limiter.isShutdown());
  } finally {
    executor.shutdownNow();
  }
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
@Test
public void runListenerExecutorTest() {
  PriorityScheduler executor = new StrictPriorityScheduler(1);
  try {
    TestRunnable tr = new TestRunnable();
    onceHelper.runListener(tr, executor, true);
    tr.blockTillFinished();
    
    assertTrue(tr.ranOnce());
    assertTrue(Thread.currentThread() != tr.lastRanThread);
  } finally {
    executor.shutdownNow();
  }
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
@Test
public void limitExecutionPerCycleStressTest() {
  PriorityScheduler scheduler = new StrictPriorityScheduler(3);
  final AtomicBoolean testComplete = new AtomicBoolean(false);
  try {
    final Integer key1 = 1;
    final Integer key2 = 2;
    Executor singleThreadedExecutor = new ExecutorLimiter(scheduler, 1);
    final KeyDistributedExecutor distributor = new KeyDistributedExecutor(2, singleThreadedExecutor, 2);
    final AtomicInteger waitingTasks = new AtomicInteger();
    final AtomicReference<TestRunnable> lastTestRunnable = new AtomicReference<>();
    scheduler.execute(new Runnable() {  // execute thread to add for key 1
      @Override
      public void run() {
        while (! testComplete.get()) {
          TestRunnable next = new TestRunnable() {
            @Override
            public void handleRunStart() {
              waitingTasks.decrementAndGet();
              
              TestUtils.sleep(20);  // wait to make sure producer is faster than executor
            }
          };
          lastTestRunnable.set(next);
          waitingTasks.incrementAndGet();
          distributor.execute(key1, next);
        }
      }
    });
    
    // block till there is for sure a backup of key1 tasks
    new TestCondition(() -> waitingTasks.get() > 10).blockTillTrue();
    
    TestRunnable key2Runnable = new TestRunnable();
    distributor.execute(key2, key2Runnable);
    TestRunnable lastKey1Runnable = lastTestRunnable.get();
    key2Runnable.blockTillStarted();  // will throw exception if not started
    // verify it ran before the lastKey1Runnable
    assertFalse(lastKey1Runnable.ranOnce());
  } finally {
    testComplete.set(true);
    scheduler.shutdownNow();
  }
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
@Override
public void shutdown() {
  for (PriorityScheduler ps : schedulers) {
    ps.shutdownNow();
  }
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
@Test
public void limitTest() throws InterruptedException, ExecutionException {
  Object key = new Object();
  int rateLimit = 100;
  final AtomicInteger ranPermits = new AtomicInteger();
  PriorityScheduler pse = new StrictPriorityScheduler(32);
  try {
    KeyedRateLimiterExecutor krls = new KeyedRateLimiterExecutor(pse, rateLimit);
    ListenableFuture<?> lastFuture = null;
    double startTime = Clock.accurateForwardProgressingMillis();
    boolean flip = true;
    for (int i = 0; i < TEST_QTY * 2; i++) {
      final int permit = 5;
      if (flip) {
        lastFuture = krls.submit(permit, key, new Runnable() {
          @Override
          public void run() {
            ranPermits.addAndGet(permit);
          }
        });
        flip = false;
      } else {
        lastFuture = krls.submit(permit, key, new Callable<Void>() {
          @Override
          public Void call() {
            ranPermits.addAndGet(permit);
            return null;
          }
        });
        flip = true;
      }
    }
    lastFuture.get();
    long endTime = Clock.accurateForwardProgressingMillis();
    double actualLimit = ranPermits.get() / ((endTime - startTime) / 1000);
    
    assertEquals(rateLimit, actualLimit, SLOW_MACHINE ? 75 : 50);
  } finally {
    pse.shutdownNow();
  }
}
 

import org.threadly.concurrent.PriorityScheduler; //导入方法依赖的package包/类
public static void main(String args[]) {
  if (args.length == 0) {
    System.err.println("Must provide at least one valid path to inspect");
    System.exit(1);
  }
  
  List<File> examineDirectories = new ArrayList<File>(args.length);
  for (String path : args) {
    File toInspectPath = new File(path);
    if (! toInspectPath.exists()) {
      throw new IllegalArgumentException("Path does not exist: " + path);
    } else if (! toInspectPath.isDirectory()) {
      throw new IllegalArgumentException("Path is not a directory: " + path);
    }
    
    examineDirectories.add(toInspectPath);
  }
  
  int threadCount = Runtime.getRuntime().availableProcessors();
  final PriorityScheduler scheduler = new PriorityScheduler(threadCount, TaskPriority.High, 1000, false);
  scheduler.execute(new Runnable() {
    @Override
    public void run() {
      scheduler.prestartAllThreads();
    }
  });
  try {
    FileCrawler fc = new FileCrawler(scheduler);
    
    if (EXCLUDE_HIDDEN) {
      fc.addFilter(new HiddenFileFilter());
    }
    
    FileNameInspector fni = new FileNameInspector();
    fc.addListener(fni);
    
    DuplicateFileInspector dfi = new DuplicateFileInspector();
    fc.addListener(dfi);
    
    // blocks till computation is done
    fc.crawlDirectories(examineDirectories);

    List<File> renameFiles = fni.getNotableFiles();
    String duplicateResult = dfi.getDuplicateAnalysis(scheduler);
    {
      if (! renameFiles.isEmpty()) {
        System.out.println();
        
        System.out.println("Files for possible rename: ");
        Iterator<File> it = renameFiles.iterator();
        while (it.hasNext()) {
          System.out.println(it.next().getAbsolutePath());
        }
      }
    }
    {
      if (! duplicateResult.isEmpty()) {
        if (! renameFiles.isEmpty()) {
          System.out.println();
        }
        System.out.println(duplicateResult);
      }
    }
    
    System.out.println("\nDONE!!");
  } catch (Throwable t) {
    System.err.println("Thrown exception from main thread, shutting down");
    t.printStackTrace(System.err);
    
    scheduler.shutdownNow();
  } finally {
    scheduler.shutdown();
  }
}