Java-线程池的使用

最新推荐文章于 2023-03-17 15:45:55 发布
最新推荐文章于 2023-03-17 15:45:55 发布
阅读量232 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38405354/article/details/106463717
版权

线程池的使用

  1. 线程池基础
  2. 线程池使用
  3. 线程池综合案例
  4. 线程池总结
1. 线程池基础
1.1 什么是线程池

线程池是存储线程的容器，线程事先创建好后放入线程池，当有任务需要执行时,直接从线程池拿空闲线程使用,使用完毕后归还给线程池.

1.2 为什么使用线程池

在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁，这就是”池化资源”技术产生的原因。线程池顾名思义就是事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。

1.3 线程池有哪些优势

a) 线程和任务分离，提升线程重用性；
b) 控制线程并发数量，降低服务器压力，统一管理所有线程；
c) 提升系统响应速度，加入创建线程用的回见为T1，执行任务用的时间为T2，销毁线程用的时间为T3，那么使用线程池就免去了T1和T3的时间。

1.4 线程池的引用场景
  • 引用场景：
    1. 网购商品秒杀；
    2. 云盘文件上传与下载
    3. 12306网上购票系统等
  • 总之
    只要有并发的地方、任务数量大或小、每次任务执行时间长或端的都可以使用线程池；只不过在使用线程池的时候，注意一下设置合理的线程池大小即可。
2. 线程池使用
2.1 ThreadPoolExecutor类

java内置线程池类
在这里插入图片描述
corePoolSize（核心线程数）： 当任务提交到线程池时，如果当前运行的线程数量没有达到核心线程池数，就会新开一个线程来执行这个任务。
maximumPoolSize（最大线程数）：允许创建出的最大线程数量。
keepAliveTime（最大空闲时间）：当一个线程不被适用，允许空闲的时间。
TimeUnit（时间单位）：枚举类
workQueue（任务队列）：一个集合，当线程数量达到核心线程数量，再提交新任务会被压到任务队列，一个临时的缓冲区。
threadFactory（线程工厂）：允许创建自己的线程。
rejectedExecutionHandler（饱和处理机制）：当任务数量达到核心线程总数、最大线程数量、队列已满，暂时无法再处理任务，则使用饱和处理机制处理新任务。
线程池工作流程：
在这里插入图片描述

2.2 自定义线程池-参数设计分析
  • 通过观察Java中的内置线程池参数讲解和线程池工作流程总结，我们不难发现，要设计一个好的线程池，就必须合理的设置线程池的4个参数；那到底该如何合理的设计4个参数的值呢？
2.2.1 四个参数的设计
    1. 核心线程数（corePoolSize）
      核心线程数的设计需要依据任务的处理时间和每秒产生的任务数量来确定，例如：执行一个任务需要0.1秒，系统百分之80的时间每秒会产生100个任务，那么想在1秒内处理完这100个任务，就需要10个线程，此时我们就可以设计核心线程数为10，当然实际情况不可能那么平均，所以一般按照8020原则设计即可，即按照百分之80的情况设计核心线程，剩下的百分之20利用最大线程数处理。
    1. 任务队列长度（workQueue）
      任务队列长度一般设计为：核心线程数、单个任务执行时间* 2即可；例如：在上面的场景中，核心线程设计为10，单个任务执行时间为0.1，则队列长度可以设计为200.
    1. 最大线程数（maximumPoolSzie）
      最大线程数的设计粗了需要参照核心线程数的条件外，还需要参照系统每秒产生的最大任务数决定。例如：上述环境中，如果系统每秒产生的任务是1000个，那么最大线程数=（最大任务数-任务队列长度）* 单个任务执行时间。即：最大线程数=（1000-200）* 0.1=80个
    1. 最大空闲时间（keepAliveTime）
      这个参数的设计完全参考系统运行环境和硬件压力设定，没有固定的参考值，用户可以根据经验和系统产生任务的时间间隔合理设计一个值即可。
2.2.2 实现步骤
  1. 编写任务类（MyTask），实现Runnable接口；
  2. 编写线程类（MyWorker），用于执行任务，需要持有所有任务；
  3. 编写线程池类（MyThreadPool），包含提交任务，执行任务的能力；
  4. 编写测试类（MyTest），创建线程池丢向，提交多个任务测试；
/**
 * 需求：自定义线程池练习，这是任务类，需要实现Runnable接口
 *           包含任务编号，每个任务执行时间为0.2秒
 */
public class MyTask implements Runnable {
       private int id;
       //由于run方法是重写接口中的方法，因此id这个属性初始化可以利用构造方法完成
       public MyTask(int id) {
             this.id = id;
       }
       @Override
       public void run() {
             String name=Thread.currentThread().getName();
             System.out.println("线程："+name+"即将执行任务"+id);
             try {
                    Thread.sleep(200);
             } catch (Exception e) {}
             System.out.println("线程："+name+"完成了任务"+id);
       }
       @Override
       public String toString() {
             return "MyTask [id=" + id + "]";
       }
}

/**
 * 需求：编写一个线程类，继承Thread类，设计一个属性用于保护线程的名字
 *          设计一个集合，用于保存所有的任务
 */
public class MyWorker extends Thread{
       private String name;         //保存线程的名字
       private List<Runnable> tasks;
       //利用构造方法给成员变量赋值
       public MyWorker(String name, List<Runnable> tasks) {
             this.name = name;
             this.tasks = tasks;
       }
       @Override
       public void run() {
             //判断集合中是否有任务，只要有就一直执行
             while(tasks.size()>0) {
                    Runnable r=tasks.remove(0);
                    r.run();
             }
       }
}

/**
 * 自定义的线程池类
 *       成员变量：
 *     1. 任务队列  --集合，线程安全问题
 *     2. 当前线程数量
 *     3. 核心线程数
 *     4. 最大线程数
 *     5. 任务队列长度
 *    成员方法：
 *     1.提交任务：直接将任务添加到集合中，需要判断是否超出总长度
 *      2.执行任务：判断当前线程的数量，决定核心线程还是非核心线程
 */          
public class MyThreadPool {
       // 1.任务队列  --集合，线程安全问题
       private List<Runnable> tasks=Collections.synchronizedList(new 
LinkedList<>());
       // 2.当前线程数量
       private int num;
       // 3.核心线程数
       private int corePoolSize;
       // 4.最大线程数
       private int maxSize;
       // 5.任务队列长度
       private int workSize;
       public MyThreadPool(int corePoolSize, int maxSize, int workSize) {
             this.corePoolSize = corePoolSize;
             this.maxSize = maxSize;
             this.workSize = workSize;
       }
       public void submit(Runnable r) {
             //判断当前集合中任务的数量是否超出了最大任务数量
             if(tasks.size()>=workSize) {
                    System.out.println("任务："+r+"被丢弃了、、、");
             }else {
                    tasks.add(r);
                    execTask(r);
             }
       }
       // 2. 执行任务
       public void execTask(Runnable r) {
             //判断当前线程池中的线程总数量，是否超出了核心数
             if(num<corePoolSize) {
                    new MyWorker("核心线程："+num,tasks).start();
                    num++;
             }else if(num<maxSize){
                    new MyWorker("非核心线程："+num,tasks).start();
                    num++;
             }else {
                    System.out.println("任务"+r+"被缓存来了");
             }
       }
}

/**
 *     测试类：
 *           1. 创建线程池类对象；
 *           2. 提交多个任务
 */
public class MyTest {
       public static void main(String[] args) {
             // 1. 创建线程池类对象；
             MyThreadPool myThreadPool=new MyThreadPool(2,4,10);
             // 2. 提交多个任务
             for (int i = 0; i < 20; i++) {
                    MyTask my=new MyTask(i);
                    myThreadPool.submit(my);
             }
       }
}

输出结果：
线程：Thread-0即将执行任务0
线程：Thread-1即将执行任务1
线程：Thread-2即将执行任务2
任务MyTask [id=4]被缓存来了
线程：Thread-3即将执行任务3
任务MyTask [id=5]被缓存来了
…
任务MyTask [id=12]被缓存来了
任务MyTask [id=13]被缓存来了
任务：MyTask [id=14]被丢弃了、、、
…
任务：MyTask [id=19]被丢弃了、、、
线程：Thread-1完成了任务1
线程：Thread-2完成了任务2
线程：Thread-2即将执行任务5
线程：Thread-0完成了任务0
…
线程：Thread-1完成了任务10
线程：Thread-3完成了任务13
线程：Thread-2完成了任务12

2.3 Java内置线程池-ExecutorService
  • ExecutorService接口是java内置的线程池接口，源码如下：
public interface ExecutorService extends Executor {
    // 启动一次顺序关闭，执行以前提交的任务，但不接受新任务。
    void shutdown();
    // 停止所有正在执行的任务，暂停处理正在等待的任务，并返回等待执行的恩物列表。
    List<Runnable> shutdownNow();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
    // 执行但返回值的任务，返回一个Future对象
    <T> Future<T> submit(Callable<T> task);
    // 执行Runnable任务，并返回一个表示该任务的Future
    <T> Future<T> submit(Runnable task, T result);
    // 执行Runnable任务，并返回一个表示该任务的Future
    Future<?> submit(Runnable task);
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}
  • 既然ExecutorService是一个接口，接口是无法直接创建对象的，那么如何获取ExecutorService对象呢？
2.3.1 ExecutorService获取

获取ExecutorService可以利用JDK中的Executors类中的静态方法，常用的获取方式如下：

  1. static ExecutorService newCachedThreadPool() ：创建一个默认的线程池对象，里面的线程可重用，且在第一次使用时才创建
  2. static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) ：线程池中的所有线程都使用ThreadFactory来创建，这样的线程无需手动启动，自动执行
  3. static ExecutorService newFixedThreadPool(int nThreads) ：创建一个可重用固定线程数的线程池
  4. static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) ：创建一个可重用固定线程数的线程且线程池中的所有线程都使用ThreadFactory来创建。
  5. static ExecutorService newSingleThreadExecutor() ：创建一个使用单个worker线程的Executor，以无解队列方式来运行该线程。
  6. static ExecutorService newSingleThreadExecutor(ThreadFactorry threadFactory) ：创建一个使用单个worker线程的Executor，且线程池中的所有线程都使用ThreadFactory来创建。
2.4 Java内置线程池-ScheduledExecutorService

ScheduledExecutorService是ExecutorService的子接口，具备了延迟运行或定期执行任务的能力
获取方式如下：

  1. static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 创建一个可重用固定线程数的线程池且允许延迟运行或定期执行任务；
  2. static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory) 创建一个可重用固定线程数的线程池且线程池中的所有线程都是用ThreadFactory来创建，且允许延迟运行或定期执行任务；
  3. static ScheduledExecutorService newSingleThreadScheduledExecutor() : 创建一个单线程执行程序，它允许在给定延迟后运行命令或者定期地执行。
  4. static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) ： 创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。
2.4.1 ScheduledExecutorService的常用方法
  1. ScheduledFuture schedule( Callable callable, long delay, TimeUnit unit) : 延迟时间单位是unit，数量是delay的时间后执行callable。
  2. ScheduledFuture<?> schedule( Runnable command, long delay, TimeUnit unit) : 延迟时间单位是unit，数量是delay的时间后执行command。
  3. ScheduledFuture<?> scheduleAtFixedRate( Runnable command, long initialDelay, long period, TimeUnit unit) ：延迟时间单位是unit，数量是initialDelay的时间后，每间隔period时间重复执行一次command。
  4. ScheduledFuture<?> scheduleWithFixedDelay（Runnable command, long initialDelay, long period, TimeUnit unit) ：创建并执行一个在给定初始延迟后首次启动的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。
public class ScheduledExecutorServiceDemo1 {    
    public static void main(String[] args) {        
        // 1.获取一个具备延迟执行任务的线程池对象        
        //ScheduledExecutorService es = Executors.newScheduledThreadPool(4)
        //        ScheduledExecutorService es =
        //                Executors.newScheduledThreadPool(5,
        //                        new ThreadFactory() {
        //                            int n;
        //                            @Override
        //                            public Thread newThread(Runnable r) {
        //                                return new Thread(r,"自定义的线程名:"+n++);
        //                            }
        //                        });                
        ScheduledExecutorService es =Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {                            
        int n;    
        @Override                           
        public Thread newThread(Runnable r) {                                
            return new Thread(r,"自定义的线程名:"+n++);                            
        }                       
});        
        // 2.创建多个任务对象，提交任务，每个任务延迟2秒执行
        //        for (int i = 0; i <10 ; i++) {
        //            es.schedule(new MyRunnable(i),2, TimeUnit.SECONDS);
        //        }        
        //es.scheduleAtFixedRate(new MyRunnable(1),1,2,TimeUnit.SECONDS); 
        es.scheduleWithFixedDelay(new MyRunnable(1),1,2,TimeUnit.SECONDS);    
        System.out.println("over");    
}
}

class MyRunnable implements Runnable{    
    private int id;    
    public MyRunnable(int id) {
         this.id = id;  
    }    
    @Override    
    public void run() {        
        String name = Thread.currentThread().getName();        
        System.out.println(name+"执行了任务"+id);        
        try {            
            Thread.sleep(2000);        
        } catch (InterruptedException e) {
            e.printStackTrace();       
        }    
    }
}
2.5 Java内置线程池-异步计算结果（Future）

我们刚刚在学习java内置线程池时，没有考虑线程计算的结果，但开发中，我们有时需要利用线程进行一些计算，然后获取这些计算的结果，而java中的Future接口就是专门用于描述异步计算结果的，我们可以通过Future对象获取线程计算的结果；
Future的常用方法如下：
boolean cancel（boolean mayInterruptIfRunning） : 试图取消对此任务的执行。
V get() ：如有必要，等待计算完成，然后获取其结果。
V get(long timeout,TimeUnit unit) ：如有必要，最多等待为使计算完成所给的时间之后，获取其结果（如果结果可用）。
boolean isCancelled() 如果在任务正常完成前将其取消，则返回true。
boolean isDone() ：如果任务已完成，则返回true。

public class Test2 {
      public static void main(String[] args) throws Exception{
            // 1.获取线程池对象
            ExecutorService es=Executors.newCachedThreadPool();
            // 2.创建<u>Callable</u>类型的任务对象
            Future<Integer> <u>future</u>=es.submit(new MyCall(1, 3));
            // 3.判断任务是否已经完成
            //test1(future);
            
//          boolean b=future.cancel(true);
//          System.out.println("取消任务执行的结果："+b);
            
//          Integer i=future.get(1,TimeUnit.SECONDS); //由于等待时间过短，任务来不及完成，会报异常
//          System.out.println("任务执行的结果是："+i);
      }

      //正常测试流程
      public void test1(Future<Integer> future) throws Exception{
            boolean done=future.isDone();
            System.out.println("第一次判断任务是否已经完成："+done);
            boolean cancel=future.isCancelled();
            System.out.println("第一次判断任务是否已经取消："+cancel);
            Integer i=future.get();//一直等待任务的执行，直到完成为止
            System.out.println("任务执行的结果是："+i);
            boolean done2=future.isDone();
            System.out.println("第二次判断任务是否已经完成："+done2);
            boolean cancel2=future.isCancelled();
            System.out.println("第二次判断任务是否已经取消："+cancel2);
      }
}

class MyCall implements Callable<Integer>{
      private int a;
      private int b;
      public MyCall(int a,int b){
            this.a=a;
            this.b=b;
      }
      @Override
      public Integer call() throws Exception {
            String name=Thread.currentThread().getName();
            System.out.println(name+"准备开始计算...");
            Thread.sleep(2000);
            System.out.println(name+"计算完成...");
            return a+b;
      }
}
3 线程池综合案例
3.1 综合案例-秒杀商品
  • 案例介绍
    假如某网上商城推出活动，新上架10部新手机免费送客户体验，要求所有参与活动的人员在规定的时间同时参与秒杀争抢，假如有20人同时参加了该活动，请使用线程池模拟这个场景，保证前10人秒杀成功，后10人秒杀失败。
  • 要求
    1. 使用线程池创建线程
    2. 解决线程安全问题
  • 思路提示：
    1. 既然商品总数量是10个，name我们可以在创建线程池的时候初始化线程数是10个及以下，设计线程池最大数量为10个；
    2. 当某个线程执行完任务之后，可以让其他秒杀的人继续使用该县城参与秒杀；
    3. 使用synchronized控制线程安全，放置出现错误数据；
  • 代码步骤：
    1. 编写任务类，主要是送出手机给秒杀成功的客户；
    2. 编写主程序类，创建20个任务（模拟20个客户）；
    3. 创建线程池对象，并接受20个任务，开始执行任务。
/**
 * 任务类，包含了商品数量、客户名称、送手机的行为
 */
public class MyTask implements Runnable{
      // 设计一个变量，用于表示上商品的数量
      private static int id=10 ;
      // 表示客户名称的变量
      private String userName;
      public MyTask (String userName){
           this.userName=userName;
      }
      @Override
      public void run() {
            String name = Thread.currentThread().getName();
            System.out.println(userName+"正在参与秒杀任务..");
            try {
                  Thread.sleep(200);
            } catch (InterruptedException e) {
            }
            synchronized (MyTask.class) {
                  if(id>0){
                        System.out.println(userName+"使用"+name+"秒杀"+id--+"号商品成功");
                  }else{
                        System.out.println(userName+"使用"+name+"秒杀"+id--+"号商品失败");
                  }
            }
      }
}

/**
 * 主程序类
 * @author Administrator
 *
 */
public class MyTest {
      public static void main(String[] args) {
            //1. 创建一个线程池对象
            ThreadPoolExecutor pool=new ThreadPoolExecutor(3,5,1,TimeUnit.MINUTES,new LinkedBlockingQueue<Runnable>(15));
            // 2. 循环创建任务对象
            for (int i = 0; i < 20; i++) {
                  MyTask myTask=new MyTask("客户"+i);
                  pool.submit(myTask);
            }
            // 3.关闭线程池
            pool.shutdown();
      }
}
3.2 综合案例-取款业务
  • 案例介绍
    设计一个程序，使用两个线程模拟在两个地点同时从一个账号曲线，假如卡中一共有1000元，每个线程取800元，要求演示结果一个线程取款成功，剩余200元，另一个线程取款失败，余额不足。
  • 要求
    1. 使用线程池创建对象
    2. 解决线程安全问题
  • 思路提示：
    1. 线程池可以利用Executors工厂类的静态方法，创建线程池对象；
    2. 解决线程安全问题可以使用synchronized关方法控制取钱的操作；
    3. 在取款前，先判断余额是否足够，且保证余额判断和取钱行为的原子性。
public class MyTest {
      public static void main(String[] args) {
            //1. 创建线程池对象
            ExecutorService es=Executors.newFixedThreadPool(2,new 
ThreadFactory() {
                  int id=1;
                  @Override
                 public Thread newThread(Runnable r) {
                        return new Thread(r,"ATM:"+id++);
                  }
            });
            // 2.创建量词任务提交
            es.submit(new MyTask("客户1",800));
            es.submit(new MyTask("客户2",800));
            es.shutdown();
      }
}

public class MyTask implements Runnable{
      //用户姓名
      private String userName;
      // 取款金额
      private double money;
      // 总金额
      private static double total =1000;
      public MyTask(String userName, double money) {
            this.userName = userName;
            this.money = money;
      }
      @Override
      public void run() {
            String name = Thread.currentThread().getName();
            System.out.println(userName+"正在准备使用"+name+"取款:"+money+"元");
            try {
                  Thread.sleep(200);
            } catch (InterruptedException e) {
            }
            synchronized (MyTask.class) {
                  if(total-money>0){
                        System.out.println(userName+"正在准备使用"+name+"取款:"+money+"元成功，余额："+(total-money)+"元");
                        total-=money;
                  }else{
                        System.out.println(userName+"正在准备使用"+name+"取款:"+money+"元失败");
                  }
            }
      }
}
4. 总结：

线程池的使用步骤可以归纳总结为五步：

  1. 利用Executors工厂类的静态方法，创建线程池对象；
  2. 编写Runnable或Callable实现类的实例对象；
  3. 利用ExecutorService的submit方法或ScheduledExecutorService的schedule方法提交并执行线程任务；
  4. 如果有执行结果，则处理异步执行结果；
  5. 调用shutdown()方法，关闭线程池。
飞鹤师兄
关注
专栏目录
Java学习----线程池
hanxuya的博客
09-09 1286
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收重用时则新建线程。}工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger.MAX_VALUE), 这样可灵活的往线程池中添加线程。如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
java-线程池ExecutorService -实现多线程任务
an_999的博客
07-25 748
java-多线程
Java线程池常用方法
lgxzzz的博客
03-22 376
在Java5之后，并 发线程这块发生了根本的变化，最重要的莫过于新的启动、调度、管理线程的一大堆API了。在Java5以后，通过Executor来启动线程比用 Thread的start（）更好。在新特征中，可以很容易控制线程的启动、执行和关闭过程，还可以很容易使用线程池的特性。 　　一、创建任务 　　任务就是一个实现了Runnable接口的类。 　　创建的时候实run方法即可。 　　二、执...
线程-线程池
小净的博客
10-14 391
一、Thread中的start和run方法的区别 1. start()方法会创建一个新的子线程 2. run()方法只是Thread的一个不同方法 二、Thread和Runnable是什么关系 1. Thread 是一个类需要继承该类 ![Thread实现](https://img-blog.csdnimg.cn/20201014144427502.jpg#pic_center) 2. Runnable 是一个接口需要实现该接口 ![Runnable实现](https://img-blog
关于Future.cancel(false)
StefanTimber的博客
06-27 2万+
前言在学习Future接口的过程中，注意到它具有一个cancel()方法，用于取消异步的任务，它传入一个boolean类型的参数，传入true会中断线程停止任务，而传入false则会让线程正常执行至完成，并返回false。 由此让我产生了疑问，false参数并不会停止任务，那么cancel(false)有什么用呢？
17.Future 介绍与主要用法
daohangtaiqian的博客
03-17 2542
Future 最主要的作用是
Future的isDone()方法结果为true代表了什么？
绅士jiejie的博客
04-24 1万+
先写个Future调用isDone()方法，返回结果是正常的示例 public class SpringbootApplication { //构建一个线程任务 static class DoSomeThing implements Callable { @Override public Object call() throws Excepti...
java-线程池 test
06-11
java-线程池 test
JAVA并发编程实践-线程池-学习笔记
最新发布
07-22
Java并发编程实践中的线程池是...总之，理解和掌握Java线程池的原理和配置技巧，能帮助开发者编写出高效、稳定的并发程序，提升系统性能。在实践中，应结合具体业务需求灵活调整线程池参数，以达到最佳的并发执行效果。
JAVA-线程池配置
weixin_46690278的博客
06-10 252
线程池配置
jdk 8-future 异步处理-轮询isDone判断完成-springBoot示例
privateobject的博客
07-29 2551
Future接口用于获取异步计算的结果，可通过get()获取结果、cancel()取消、isDone()判断是否完成等操作。get阻塞方式，任务不是最早结束的就能得到结果值，是按照自定义key的 顺序获取结果。 isDone轮询方式，任务是在主线程循环判断，结果顺序是和任务耗时有关，代码较多。 个人见解，如有问题请指出。...
利用Future异步获取多线程的返回结果
z69183787的专栏
10-24 1万+
Future接口是Java标准API的一部分，在java.util.concurrent包中。Future接口是Java线程Future模式的实现，可以来进行异步计算。 有了Future就可以进行三段式的编程了，1.启动多线程任务2.处理其他事3.收集多线程任务结果。从而实现了非阻塞的任务调用。在途中遇到一个问题，那就是虽然能异步获取结果，但是Future的结果需要通过isdone来判断是否有结
task
D_XQY_的博客
11-29 327
https://www.cnblogs.com/yinjun98/p/12307014.html C# Task详解 C# Task和async/await详解 什么是异步 同步和异步主要用于修饰方法。当一个方法被调用时，调用者需要等待该方法执行完毕并返回才能继续执行，我们称这个方法是同步方法；当一个方法被调用时立即返回，并获取一个线程执行该方法内部的业务，调用者不用等待该方法执行完毕，我们称这个方法为异步方法。 异步的好处在于非阻塞(调用线程不会暂停执行去等待子线程完成)，因此我们把一些不需要立即使用结果
Spring Boot 实现监控子线程的执行结果2种方法（Future.isDone()、事件监听器）
旭东怪的博客
09-18 2517
1 Maven依赖 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <!--hutool工
Future 总结
toneylyx的博客
03-21 383
1. 关于FutureFuture接口包含以下方法： boolean cancel(boolean mayInterruptIfRunning)*取消任务的执行。参数指定是否立即中断任务执行，或者等等任务结束 boolean isCancelled() *任务是否已经取消，任务正常完成前将其取消，则返回 true boolean isDone()*任务是否已经完成。需要注意的是如果任务正常
FutureTask isDone 返回 false
烤鸭的世界我们不懂的博客
07-07 1419
大家好，我是烤鸭： ​     今天看一下 FutureTask源码。好吧，其实遇到问题了，哪里不会点哪里。 伪代码 package src.executor; import org.springframework.scheduling.annotation.AsyncResult; import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; import java.util.c
Controller 层返回值的公共包装类-避免每次都包装一次返回-InitializingBean增强
热门推荐
hu10131013的博客
09-07 10万+
场景：在微服务中，一般返回数据都会有个返回码、返回信息和返回消息体，但是每次返回时候调用或者是封装，太过麻烦，有没有什么办法不用每次都封装呢？ 答案是有的。 返回值对象 package com.study.auth.comm; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.annotation.JSONField; import com.alibaba.fastjson.serializer.Serialize..
future.get方法阻塞问题的解决，实现按照任务完成的先后顺序获取任务的结果
fourierr的博客
05-14 6万+
1、Future Future模式是多线程设计常用的一种设计模式。Future模式可以理解成：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后，我就便可以从Future那儿取出结果。 Future提供了三种功能： 判断任务是否完成 能够中断任务 能够获取任务执行的结果 向线程池中提交任务的submit方法不是阻塞方法，而Future...
《JAVA并发编程实践-线程池高级选项及任务执行框架注意事项学习笔记》
本文是关于《JAVA并发编程实践-线程池-学习笔记》中配置和调整线程池时使用的高级选项的总结，重点讲述了在任务执行框架的过程中需要注意的危险。其中包括线程复用原理、线程池的实现原理以及线程池的组成等内容。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值