Java中的线程池和异步任务详解

最新推荐文章于 2024-08-28 18:11:18 发布
最新推荐文章于 2024-08-28 18:11:18 发布
阅读量1.9k 收藏 11
点赞数
分类专栏： 知识总结 文章标签： java线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40414855/article/details/100041139
版权

Java中的线程池和异步任务详解

转载自：https://blog.csdn.net/fanrenxiang/article/details/79855992
引言
java中经常需要用到多线程来处理一些业务，我们非常不建议单纯使用继承Thread或者实现Runnable接口的方式来创建线程，那样势必有创建及销毁线程耗费资源、线程上下文切换问题，这个时候引入线程池比较合理。有些时候也需要把多线程的逻辑给异步话，接口不需要等待子线程逻辑执行完就马上返回，这里就需要异步任务。java中涉及到线程池的相关类均在jdk1.5开始的java.util.concurrent包中，涉及到的几个核心类及接口包括：ExecutorService、Executors、ThreadPoolExecutor、FeatureTask、Callable、Runnable等。后面会一一描述。
接口流程图伪代码思路如下：

 @ResponseBody
    @RequestMapping(value = "/notifyOrder", method = RequestMethod.POST)
    public CommonResult notifyOrder(@RequestParam(value = "req", required = false) String req) {
        log.info("notifyOrder method parameter：req={}", req);
        CommonResult result = new CommonResult();
        // 1、校验工作
 
        //  2、decode送过来的原始数据并序列化
        PointsMallOrderInfo orderInfo = StringToBean(req, "data", PointsMallOrderInfo.class);
 
        // 3、保存推送过来的原始数据
        orderInfoService.addOrderInfo(orderInfo);
 
        // 4、获取系统中状态为可用的虚拟码
 
        // 5、多线程异步处理 发送短信、提交虚拟码
        AsynSendAndSubmitTask.asynSendAndSubmit(orderInfo);
 
        // 6、持久化虚拟码流水号等信息
        return result;
    }
 
public class AsynSendAndSubmitTask {
    private static ExecutorService asynSendAndSubmitThreadPool = new ThreadPoolExecutor(10, 10, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(40));
 
    public static void asynSendAndSubmit(final PointsMallOrderInfo orderInfo) {
        asynSendAndSubmitThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                // 短信下发虚拟码给用户
                Long messageId = smsService.sendSms(new SendSmsInfo());
                // 给积分商城提交虚拟码
                String submitResult = HttpUtil.httpPost(false, params, SETVIRTUALCODE_URL);
            }
        });
    }
}

我们程序逻辑主线程中执行“保存推送过来的基础数据、查询并取出可用的充值码、持久化充值码及相关流水号信息操作，但提交虚拟码和短信发送虚拟码则以多线程的方式异步处理，加快接口响应。（当然也可以用kafka/MQ之类的消息队列替代）

角色划分
1、任务：指的是实现了Callable或Runnable接口的类，里面包含主要的业务逻辑，任务用于提交至线程池里的线程去执行。实现Callable接口的任务类可以有返回值，而Runnable接口则无；
2、异步计算结果：主要是FutureTask类，里面包含了异步任务的计算结果，可以理解为执行单元，用于提交至线程池时使用；
3、线程池：ThreadPoolExecutor和Executors类，用于构建线程池。
Executors 和ThreadPoolExecutor
由源码可知Executors本质上还是使用的ThreadPoolExecutor来实例化线程池的，Executors类可以创建四种类型的线程池，分别为 newFixedThreadPool、newSingleThreadExecutor、newCachedThreadPool、newScheduledThreadPool
FixedThreadPool
使用固定线程数，适用于为了平衡服务器资源而指定线程数的场景，一般用于负载比较高的服务器

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

如上是在ThreadPoolExecutor类中的源码，可以看到newFixedThreadPool线程池重用放在"共享无边界的队列LinkedBlockingQueue"中的固定线程数，处理任务时，nThread大部分都将以活动状态在处理任务，如果当所有线程都处于活动状态时又有额外的任务提交，那么新任务将在队列中等待直至线程可用。
SingleThreadExecutor
使用单个线程数，适用于需要保证顺序的执行各个任务；并且在任意时间点，不会有多个线程活动的场景

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));
}

关于这种方式创建的线程池，源码中特别强调了：如果该单个线程在关闭之前由于执行过程中的失败而终止，那么如果需要执行后续任务，将替换一个新的线程，使用到的也是LinkedBlockingQueue队列。
CachedThreadPool
使用非固定线程数，适用于执行很多短期的异步任务，或者负载较轻的服务器

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);
}

根据需要创建线程，如优重用先前创建的可用线程，否则将新建线程并放到池子中，从构造函数可以看到，默认超过60秒未使用的线程将被终止并从cache中移除，使用到的同步移交SynchronousQueue队列。
ScheduledThreadPool
包含多个线程，适用于需要多个后台执行周期任务（或延迟任务），同时为了满足资源管理的需求而需要限制线程数量的场景

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

对应的还有个SingleThreadScheduledExecutor只包含单个线程，适用于需要单个后台线程执行周期性任务，同时需要保证顺序的执行各个任务的场景

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

使用Executors创建线程池的隐患
我这里以newFixedThreadPool构建的线程池为例，结合源码看看Executors.newFixedThreadPool(n)创建的线程池会有哪些潜在的隐患。进入newFixedThreadPool初始化的源码

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {……}

corePoolSize：线程池核心线程数，要注意线程池初创时候并不会启动corePoolSize个线程，而是随着任务的提交逐渐达到这个值；
maximumPoolSize：池中的最大线程数，要注意这个参数只有在任务数量大于corePoolSize时才会起作用；
keepAliveTime：当线程数大于corePoolSize时，多余空闲线程在终止之前等待新任务的最大时间；
unit：keepAliveTime的时间单位；
workQueue：用于保存任务的队列，可以为无界、有界、同步移交类型的队列，这里是BlockingQueue。当池子里的工作线程数大于corePoolSize时，这时新进来的任务才会放到阻塞队列中，；
threadFactory：创建新的线程时的工厂类，比如guava的ThreadFactoryBuilder；
handler：队列已满且线程数达到maximunPoolSize时候的饱和策略，取值有AbortPolicy、CallerRunsPolicy、DiscardOldestPolicy、DiscardPolicy；
上面说到了 FixedThreadPool、SingleThreadExecutor 源码中使用到的是LinkedBlockingQueue无界队列，而CacheThreadPool和ScheduledThreadPool实例化时默认最大线程数又是Integer.MAX_VALUE，这可能导致什么结果呢？《阿里巴巴Java开发手册v1.2.0》中这样说到：
在这里插入图片描述结合源码看：FixedThreadPool、SingleThreadExecutor的LinkedBlockQueue是一个用链表实现的有界阻塞队列，容量可以选择进行设置，默认将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE.

  /**
   * Creates a {@code LinkedBlockingQueue} with a capacity of
   * {@link Integer#MAX_VALUE}.
   */
  public LinkedBlockingQueue() {
      this(Integer.MAX_VALUE);
  }

而CacheThreadPool和ScheduledThreadPool实例化时默认最大允许创建的线程数是Integer.MAX_VALUE

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

所以上述两个"漏洞"在特定的场景下就有可能会导致OOM，故而很多人都不建议使用这颗"定时炸弹"。
创建线程池的正确姿势？
那么上面说了使用Executors创建的线程池有隐患，那如何使用才能避免这个隐患呢？对症下药，既然FixedThreadPool和SingleThreadPool"可能"导致的OOM是由于使用了无界队列任务堆积，CacheThreadPool和ScheduledThreadPool是由于"可能"创建Interger.MAX_VALUE，那创建线程池时我们就使用有界队列或者指定最大允许创建线程个数即可。使用下面的构造函数

private static ExecutorService executor = new ThreadPoolExecutor(10,10,60L, TimeUnit.SECONDS,new ArrayBlockingQueue(10));

这样可以指定corePoolSize、maximumPoolSize、workQueue为ArrayBlockingQueue有界队列

 public ThreadPoolExecutor(int corePoolSize,
                           int maximumPoolSize,
                           long keepAliveTime,
                           TimeUnit unit,
                           BlockingQueue<Runnable> workQueue) {
     this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
          Executors.defaultThreadFactory(), defaultHandler);
 }
 private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();

默认的handler队列饱和策略为AbortPolicy（直接抛出异常），当提交任务线程数高于可用线程数，队列放满而无法处理新请求，这时候会抛出java.util.concurrent.RejectedExecutionException异常，然后手动捕获即可，总比OOM强吧。当然你也可以使用guava包中的ThreadFactoryBuilder工厂类来构造线程池:

private static ThreadFactory threadFactory = new ThreadFactoryBuilder().build();
private static ExecutorService executorService = new ThreadPoolExecutor(10, 10, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10), threadFactory, new ThreadPoolExecutor.AbortPolicy());

通过guava的ThreadFactory工厂类还可以指定线程的名称，这对于后期定位错误时也是很有帮助的

ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("thread-pool-d%").build();

Future和FutureTask（异步任务结果）
Future接口和FutureTask类用来表示执行异步任务的结果，当向ThreadPoolExecutor或ScheduledThreadPoolExecutor提交了一个Callable或Runnable接口的实现类时，ThreadPoolExecutor或ScheduledThreadPoolExecutor就会返回FutureTask。到目前的jdk版本为止，submit返回的是都是实现了Future接口的FutureTask。

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

FutureTask一般都是和线程池搭配使用，用于多线程的方式提交任务，通过futureTask.get()方法获取异步任务的计算结果即可。如下代码:

import java.util.concurrent.*;
 
public class FutureTaskTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newCachedThreadPool();
        try {
            CustomCallable callable = new CustomCallable();
            FutureTask<Integer> callableTask = new FutureTask<Integer>(callable);
            executor.submit(callableTask);
            System.out.println("callableTask任务计算结果=" + callableTask.get());
 
            CustomRunnable runnable = new CustomRunnable();
            FutureTask<Void> runnableTask = new FutureTask<>(runnable, null);
            executor.submit(runnableTask);
 
        } finally {
            executor.shutdown();
        }
    }
}
 
class CustomCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            sum += i;
        }
        return sum;
    }
}
 
class CustomRunnable implements Runnable {
    @Override
    public void run() {
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            sum += i;
        }
        System.out.println("RunnableTask任务计算结果=" + sum);
    }
}

从上面代码和开头讲到的demo1场景来看，使用FutureTask后，提交给线程池的就变成了futuretask而不是简单的实现了Runnable或Callable接口的普通任务了，并且获取任务的结果也是通过futuretask.get()方法而不是executorservice.submit()返回值。
Callable和Runnable（任务类逻辑）
Callable接口和Runnable接口的实现类（近似等价于被提交任务的逻辑）均可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor所执行，区别在于执行的任务逻辑是否需要返回值，Callable接口实现类可以有返回值，而Runnable接口实现类则没有返回值；比如这里自定义一个实现了Callable接口的任务类：

class CustomCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程开始进行计算");
        Thread.sleep(500);
        int sum = 0;
        for (int i = 0; i < 10; i++)
            sum += i;
        return sum;
    }
}

也可以通过Executors类包装的如下两种方式创建任务

//此方式创建Callable对象，通过futureTask.get()方法可以获取到异步计算结果
public static <T> Callable<T> callable(Runnable task, T result) {
    if (task == null)
        throw new NullPointerException();
    return new RunnableAdapter<T>(task, result);
}
//不返回异步计算结果
public static Callable<Object> callable(Runnable task) {
    if (task == null)
        throw new NullPointerException();
    return new RunnableAdapter<Object>(task, null);
}

1、通过futureTask.get()方法获取任务计算结果时，当任务还未完成，会导致线程阻塞直至任务完成，一般会配合futureTask.isDone()方法判断子线程任务是否完成来一起使用;

2、当项目中有很多异步任务时，要着重测试下每个异步任务的执行时间，比如某个异步任务是调用其他系统的web服务，这时候就得测试调用需用的时间长短，如果过长，则建议使用生产/消费模式的消息队列去实现，不然容易使服务器的jvm进程崩溃;

线程池实现原理？
current包下的线程池实现原理相对简单，就是一个线程集合workers和存放任务的阻塞队列workQueue，当有新任务提交时就放到workQueue队列中（注:当池子里的核心线程数小于corePoolSize时任务会直接被执行），然后线程池从任务阻塞队列中"分配"任务并执行。

/**
  * 设置线程池中的所有工作线程
  */
 private final HashSet<Worker> workers = new HashSet<Worker>();
 /**
  * 用于保存任务和切换到工作线程的队列
  */
 private final BlockingQueue<Runnable> workQueue;

在这里插入图片描述Springboot中使用线程池
springboot可以说是非常流行了，下面说说如何在springboot中让spring来帮我们管理线程池


/**
 * @ClassName ThreadPoolConfig
 * @Description 构建spring管理的线程池实例，方便调用
 * @Author simonsfan
 * @Date 2018/12/20
 * Version  1.0
 */
@Configuration
public class ThreadPoolConfig {
 
    @Bean(value = "threadPoolInstance")
    public ExecutorService createThreadPoolInstance() {
        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("thread-pool-%d").build();
        ExecutorService threadPool = new ThreadPoolExecutor(10, 10, 30L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10), threadFactory, new ThreadPoolExecutor.AbortPolicy());
        return threadPool;
    }
 
}

 @Resource(name = "threadPoolInstance")
    private ExecutorService executorService;
 
    @Override
    public void spikeConsumer() {
        //TODO
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                //TODO
            }
        });
    }

总结

这篇文章主要讲的是线程池的知识，但是还是比较的基础的，如果想继续研究，还需要看一些其它的文章。

Help猿
关注
专栏目录
Java 线程池与异步任务
TechWhizZ的博客
09-28 132
线程池是一组预先创建的线程集合，用于执行多个任务。在Java中，线程池是通过接口来实现的。它负责管理线程的创建、调度和销毁，并提供一种机制来提交任务并获取任务的执行结果。本文介绍了Java线程池的概念和使用方法，并展示了如何利用线程池来执行异步任务。通过合理地使用线程池，我们可以更好地管理和复用线程，提高应用程序的性能和效率。同时，通过将耗时的操作放在后台线程中执行，可以避免阻塞主线程，提高应用程序的响应性能。在实际开发中，线程池和异步任务是非常常用的技术，特别适用于需要处理大量并发任务的场景。
一文详解java线程池 详解Java线程池的七个参数 详解池化技术 java如何选择核心线程数 详解Java线程池的拒绝策略
念兮为美
09-13 2496
本位以调用连连支付接口而使用到线程池为开篇，来详细分析java中线程池的技术。分别讲述了如下技术点：1、线程池的使用场景，比如加快请求响应，加快处理大任务等；2、线程池的池化技术；3、线程池的创建，比如手动创建和自动创建。4、ThreadPoolExecutor中重要的几个参数详解；5、阿里巴巴开发规范对线程池的限制；6、关闭线程池以及线程池能够复用的原理；7、Springboot中如何使用线程池；8、如何优化线程池；9、守护线程的使用等。.........
C# 温故而知新： 线程篇(二)
weixin_30522183的博客
07-07 171
C# 温故而知新： 线程篇(二) 线程池和异步线程 目录： 1 什么是CLR线程池？ 2 简单介绍下线程池各个优点的实现细节 3 线程池ThreadPool的常用方法介绍 4 简单理解下异步线程 5 异步线程的工作过程和几个重要的元素 6 有必要简单介绍下Classic Async Pattern 和Event-based Async Pattern 7 异步线程的发展趋势以...
JAVA多线程异步与线程池------JAVA
最新发布
春风若有怜花意，可否许我再少年
08-28 3910
JAVA多线程异步与线程池------JAVA
java多线程异步任务,java使用线程池完成异步任务
weixin_26808205的博客
03-21 440
管理系统中，在执行耗时的操作时阻塞用户主线程。用户界面迟迟得不到返回信息，甚至是超时；在这种业务场景下可以使用异步任务用户发出了一个耗时操作请求，主线程立即return如果当前异步任务没有被执行完，用户再次发起提示“有任务正在执行“，直到当前任务执行完毕才允许再次执行提供中断当前正在执行的任务功能先看看效果gif.gifjava代码package io.renren.modules.generat...
Java使用线程实现异步运行
m0_72958694的博客
07-05 2228
本文详细介绍了Java使用线程实现异步运行的三种方法，给出了三个详细的代码示例；同时介绍了在Java中实现异步运行的方法，干货满满。
Java 异步编程 (5 种异步实现方式详解)
热门推荐
AS011x的博客
09-19 1万+
首先我们先来看看一个同步的用户注册例子，流程如下：在同步操作中，我们执行到插入数据库的时候，我们必须等待这个方法彻底执行完才能执行“发送短信”这个操作，如果插入数据库这个动作执行时间较长，发送短信需要等待，这就是典型的同步场景。于是聪明的人们开始思考，如果两者关联性不强，能不能将一些非核心业务从主流程中剥离出来，于是有了异步编程雏形，改进后的流程如下：这就是异步编程，它是程序并发运行的一种手段，它允许多个事件同时发生，当程序调用需要长时间运行的方法时，它不会阻塞当前的执行流程，程序可以继续运行。
Java异步任务之线程池详解
蟹老板的博客
12-29 1973
转自：http://blog.csdn.net/u010687392/article/details/49850803 说到线程，我想大家都不陌生，因为在开发时候或多或少都会用到线程，而通常创建线程有两种方式： 1、继承Thread类  2、实现Runnable接口 虽说这两种方式都可以创建出一个线程，不过它们之间还是有一点区别的，主要区别在于在多线程访问同一资源的情况下，用Runnab...
Java 线程池异步任务
m0_73257876的博客
08-26 392
创建一个单线程的线程池。那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在 Executors类里面提供了一些静态工厂，生成一些常用的线程池。创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。...
Java四种线程池的使用详解
08-29
这种线程池非常适合执行一些短暂的异步任务，因为它可以自动地对线程进行管理和回收。示例代码如下： ```java package test; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;...
Java ExecutorService四种线程池使用详解
08-28
在Java多线程编程中，`ExecutorService` 是线程池的核心接口，它提供了一种管理线程的方式，包括创建、调度和终止线程。Java的`java.util.concurrent`包中提供了`ExecutorService`的实现类，特别是通过`Executors`...
java异步编程详解
08-26
Java异步编程是Java编程语言中的一种编程模型，它允许程序异步地执行任务，以提高程序的性能和响应速度。在Java中，异步编程可以通过多种方式实现，包括使用Future、Callable、Runnable、Thread、ExecutorService等...
Java线程池实现原理详解,看完一篇，学会线程池？
m0_49496327的博客
04-11 1399
一、为什么要使用线程池？ 线程池提供了一种限制和管理资源（线程、任务）的方式。 这里借用《Java 并发编程的艺术》提到的来说一下使用线程池的好处： 降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度：当任务到达时，任务可以不需要等待创建线程就能立即执行。 提高线程的可管理性：线程是稀缺资源，如果无线的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。 二、ThreadPoolExecutor类分析 Java线程池主要由Ex
java异步执行任务
麻辣香蕉
06-21 4308
java异步执行可以使用线程，或者第三方消息中间件，如mq； 线程池的使用： ThreadPoolExecutor es = new ThreadPoolExecutor(50, 50, 0L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), new ThreadFactory() { @Override public Thread newThread(Runnable r) {
Java - 异步处理
MinggeQingchun的博客
01-07 8390
Async注解是基础Spring的AOP动态代理模式实现的，同类中的A方法并没有走Spring的代理类，调用同类中的B方法是原生的并不是Spring所代理的对象，因为并没有经过Spring容器托管，从而造成了注解的失效。异步处理的实现方式有很多种，常见多线程，消息中间件，发布订阅的广播模式，其根据逻辑在于先把请求承接下来，放入容器中，在从容器中把请求取出，统一调度处理。异步适用的业务场景，对数据强一致性的要求不高，异步处理的数据更多时候追求的是最终一致性。5、异步用在不同服务间，可以隔离服务，避免雪崩；
JAVA项目中的异步任务
大风的博客
04-09 8172
如果需要自定义线程池需要在。
java异步任务
qq_43784314的博客
03-05 289
问题：在我们的生活中通常会遇见在邮件发送的时候，在我们点击发送邮件后，一段时间之后才会得到发送成功的响应。那么怎么才能让用户直接获得响应， 而让后台继续处理呢？ 1、解决这类问题通常会考虑到使用多线程来处理。这里利用多线程的延时来模拟响应时间。 public void hello(){ try{ Thread.sleep(3000); } catch (InterruptedException e) { e.printS
Java程序框架--多线程异步处理多任务
08-15
几乎所有的大型系统都有一个多任务多线程处理内核。本程序提供了一个多任务多线程异步处理框架。该框架使用简单，用户只需要继承抽象类Task,构建自己的任务类，再构造一个任务源，就可以轻松使用这个框架。 程序包里提供了一个例子Mytask 和MyTaskGenerator, 用户只需要运行类bootStraps即可。
java 线程池——异步任务
guanshengg的博客
08-17 3876
　为了解决这些问题，Jdk1.5之后加入了java.util.concurrent包，这个包中主要介绍java中线程以及线程池的使用。为我们在开发中处理线程的问题提供了非常大的帮助
Java 线程池-异步任务
qq_35354529的博客
07-29 530
Java通过Executors提供四种线程池，分别为： 1,newCachedThreadPoo 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 2,newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 3,newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值