java中有哪些常见的线程池

 public static ExecutorService newFixedThreadPool(int nThreads) {
 return new ThreadPoolExecutor(nThreads, nThreads,
  0L, TimeUnit.MILLISECONDS,
  new LinkedBlockingQueue<Runnable>());
 }

 public static ExecutorService newSingleThreadExecutor() {
 return new FinalizableDelegatedExecutorService
 (new ThreadPoolExecutor(1, 1,
   0L, TimeUnit.MILLISECONDS,
   new LinkedBlockingQueue<Runnable>()));
 }

 public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
 return new FinalizableDelegatedExecutorService
 (new ThreadPoolExecutor(1, 1,
   0L, TimeUnit.MILLISECONDS,
   new LinkedBlockingQueue<Runnable>(),
   threadFactory));
 }

 public static ExecutorService newCachedThreadPool() {
 return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
   60L, TimeUnit.SECONDS,
   new SynchronousQueue<Runnable>());
 }

 public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
 return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
   60L, TimeUnit.SECONDS,
   new SynchronousQueue<Runnable>(),
   threadFactory);
 }

 public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
 return new ScheduledThreadPoolExecutor(corePoolSize);
 }

 public static ScheduledExecutorService newScheduledThreadPool(
 int corePoolSize, ThreadFactory threadFactory) {
 return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
 }

 public ScheduledThreadPoolExecutor(int corePoolSize) {
 super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
 new DelayedWorkQueue());
 }

 public ScheduledThreadPoolExecutor(int corePoolSize,
   ThreadFactory threadFactory) {
 super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
 new DelayedWorkQueue(), threadFactory);
 }

 public ScheduledThreadPoolExecutor(int corePoolSize,
   RejectedExecutionHandler handler) {
 super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
 new DelayedWorkQueue(), handler);
 }

 public ScheduledThreadPoolExecutor(int corePoolSize,
   ThreadFactory threadFactory,
   RejectedExecutionHandler handler) {
 super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
 new DelayedWorkQueue(), threadFactory, handler);
 }

 public static void main(String[] args) {
 ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
 // 1. 延迟一定时间执行一次
 service.schedule(() ->{
 System.out.println("schedule ==> 云栖简码-i-code.online");
 },2, TimeUnit.SECONDS);

 // 2. 按照固定频率周期执行
 service.scheduleAtFixedRate(() ->{
 System.out.println("scheduleAtFixedRate ==> 云栖简码-i-code.online");
 },2,3,TimeUnit.SECONDS);

 //3. 按照固定频率周期执行
 service.scheduleWithFixedDelay(() -> {
 System.out.println("scheduleWithFixedDelay ==> 云栖简码-i-code.online");
 },2,5,TimeUnit.SECONDS);

 }

 public ScheduledFuture<&#63;> schedule(Runnable command,
   long delay, TimeUnit unit);

 public ScheduledFuture<&#63;> scheduleAtFixedRate(Runnable command,
    long initialDelay,
    long period,
    TimeUnit unit);

 public ScheduledFuture<&#63;> scheduleWithFixedDelay(Runnable command,
    long initialDelay,
    long delay,
    TimeUnit unit);

 public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
 return new DelegatedScheduledExecutorService
 (new ScheduledThreadPoolExecutor(1));
 }

/**
 * @url: i-code.online
 * @author: AnonyStar
 * @time: 2020/11/2 10:01
 */
public class ForkJoinApp1 {

 /**
 目标： 打印0-200以内的数字，进行分段每个间隔为10以上，测试forkjoin
 */
 public static void main(String[] args) {
 // 创建线程池，
 ForkJoinPool joinPool = new ForkJoinPool();
 // 创建根任务
 SubTask subTask = new SubTask(0,200);
 // 提交任务
 joinPool.submit(subTask);
 //让线程阻塞等待所有任务完成 在进行关闭
 try {
 joinPool.awaitTermination(2, TimeUnit.SECONDS);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 joinPool.shutdown();
 }
}

class SubTask extends RecursiveAction {

 int startNum;
 int endNum;

 public SubTask(int startNum,int endNum){
 super();
 this.startNum = startNum;
 this.endNum = endNum;
 }

 @Override
 protected void compute() {

 if (endNum - startNum < 10){
 // 如果分裂的两者差值小于10 则不再继续，直接打印
 System.out.println(Thread.currentThread().getName()+": [startNum:"+startNum+",endNum:"+endNum+"]");
 }else {
 // 取中间值
 int middle = (startNum + endNum) / 2;
 //创建两个子任务，以递归思想，
 SubTask subTask = new SubTask(startNum,middle);
 SubTask subTask1 = new SubTask(middle,endNum);
 //执行任务， fork() 表示异步的开始执行
 subTask.fork();
 subTask1.fork();
 }
 }
}

 private int num(int num){
 if (num <= 1){
 return num;
 }
 num = num(num-1) + num(num -2);
 return num;
 }

/**
 * @url: i-code.online
 * @author: AnonyStar
 * @time: 2020/11/2 10:01
 */
public class ForkJoinApp3 {

 public static void main(String[] args) throws ExecutionException, InterruptedException {
 ForkJoinPool pool = new ForkJoinPool();
 //计算第二是项的数值
 final ForkJoinTask<Integer> submit = pool.submit(new Fibonacci(20));
 // 获取结果，这里获取的就是异步任务的最终结果
 System.out.println(submit.get());

 }
}

class Fibonacci extends RecursiveTask<Integer>{

 int num;
 public Fibonacci(int num){
 this.num = num;
 }

 @Override
 protected Integer compute() {
 if (num <= 1) return num;
 //创建子任务
 Fibonacci subTask1 = new Fibonacci(num - 1);
 Fibonacci subTask2 = new Fibonacci(num - 2);
 // 执行子任务
 subTask1.fork();
 subTask2.fork();
 //获取前两项的结果来计算和
 return subTask1.join()+subTask2.join();
 }
}