java 多线程 并发 线程池 ExecutorService Executors

目录

​​几种线程池​​

​​使用选择​​

​​实现方式​​

​​有返回值的​​

​​无返回值​​

​​线程池实例化举一反三使用​​

介绍

介绍线程池种类和实现方式，优缺点。

几种线程池

• 方法签名    方法描述    自动销毁空闲线程     底层实现类
• newSingleThreadExecutor()    创建只有一个线程的线程池    不会销毁  ThreadPoolExecutor
• newFixedThreadPool(int nThreads)    创建一个固定数量线程的线程池    不会 销毁   ThreadPoolExecutor
• newCachedThreadPool()    创建一个具有缓存功能的线程池, 线程数可无限递增    线程空闲60秒后, 会自动销毁    ThreadPoolExecutor
• newSingleThreadScheduledExecutor()    创建具有调度功能的单线程池, 可延迟执行线程任务    不会销毁    ScheduledThreadPoolExecutor
• newScheduledThreadPool(int corePoolSize)    创建具有指定线程数量的线程池, 拥有延迟调度功能.    不会销毁    ScheduledThreadPoolExecutor
• newWorkStealingPool()    创建ForkJoinPool 线程池, 默认线程数量为当前cpu 的核数    不会销毁    ForkJoinPool
• newWorkStealingPool(int parallelism)    创建ForJoinPool线程池, 指定线程数量    不会销毁   ForkJoinPool

使用选择

根据需要使用， 常用的 Fixed 固定数量，控制内存最大使用量，和服务性能考虑

Cached缓存无线增加，看业务，有的线程占用小，预估不会因为大造成影响即可使用

Scheduled 用定时任务的时候使用

根据业务自行分析考虑内存，考虑性能  cpu和内存 数据库连接数等，具体分析即可

实现方式

有返回值的

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class test1 {
  public static void main(String[] args) {
    //创建线程池
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        //通过线程池管理线程MyCallable
        Future<String> future = newCachedThreadPool.submit(new t3(98));

        //如果提交的任务未完成
        if (!future.isDone()) {
            System.out.println("运行中!");
        }

        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            //关闭线程池
            newCachedThreadPool.shutdown();
        } 
  }
}

class t3 implements Callable<String> {
  private int num = 0;

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

  @Override
  public String call() {
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    return num + "5578";
  }
}

无返回值

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class test1 {
  public static void main(String[] args) {
    //创建线程池
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 3; i++) {
          newCachedThreadPool.execute(new t2(i));
    }
        newCachedThreadPool.shutdown();
        
  }
}
 
class t2 extends Thread {
  private int num = 0;

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

  public int getNum() {
    return this.num;
  }

  @Override
  public void run() {
    for (int i = 0; i < 3; i++) {
      System.out.println(num+"任务正在执行" + i);
    }
  }
}

线程池实例化举一反三使用

• 上边的几种获取线程池，都是如此方法，唯一变的就是  Executors.newFixedThreadPool(9);
• ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
• ExecutorService newCachedThreadPool = Executors.newFixedThreadPool(9);
• 有返回值 使用submit 提交
• 没有返回值使用execute 执行

ok

持续更新