从ActiveMQ异步消息异步调用的区别到线程池的总结_调用消息和异用消息之间的区别是什么-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_38070608/article/details/103769770

ActiveMQ的异步消息

MQ的异步消息指的不是必须每生产一次就消费一次。生产方只要放到消息通道里。消费方不断地去监听就可以了。异步消息可以使用JMS来编码操作。JMS本身就是异步的。直接标注上代码即可。

首先引入maven依赖：

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-activemq</artifactId>
        </dependency>

其次加上MQ的url、username、password

  spring：
  	activemq:
   	 #broker-url: tcp://localhost:61616
   	 broker-url: tcp://117.50.14.59:61616
     user: admin
   	 password: admin

在启动类中加上@EnableJms 注解。标明启用JMS注入启用。

@EnableJms
@SpringBootApplication
public class SpringbootActiveMqApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootActiveMqApplication.class, args);
    }
}

生产方注入JmsTemplate

import javax.jms.Destination;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.stereotype.Service;

@Service("producer")
public class Producer {
    @Autowired // 也可以注入JmsTemplate，JmsMessagingTemplate对JmsTemplate进行了封装
    private JmsMessagingTemplate jmsTemplate;

    // 发送消息，destination是发送到的队列，message是待发送的消息
    public void sendMessage(Destination destination, final String message) {
        jmsTemplate.convertAndSend(destination, message);
    }
}

消费方加上注解@JmsListener

import org.springframework.jms.annotation.JmsListener;  
import org.springframework.stereotype.Component;  
  
@Component  
public class Consumer {  
        // 使用JmsListener配置消费者监听的队列，其中text是接收到的消息  
    @JmsListener(destination = "mytest.queue")  
    public void receiveQueue(String text) {  
        System.out.println("Consumer收到的报文为:"+text); 
        System.out.println("================="); 
    }  
}

这样。一个简单的MQ异步消息就可以正常运作了。这属于MQ的异步消息

异步消息、异步调用、异步请求是不同的编码模式。他们应用的范畴不是一样的

异步请求与异步调用的区别

两者的使用场景不同，异步请求用来解决并发请求对服务器造成的压力，从而提高对请求的吞吐量；而异步调用是用来做一些非主线流程且不需要实时计算和响应的任务，比如同步日志到kafka中做日志分析等。

异步请求是会一直等待response相应的，需要返回结果给客户端的；而异步调用我们往往会马上返回给客户端响应，完成这次整个的请求，至于异步调用的任务后台自己慢慢跑就行，客户端不会关心。

异步请求可以直接使用多线程来做。涉及到前端后端联合编码。这里不做详细说明。主要说明异步调用的使用。

通常在开发过程中，会遇到一个方法是和实际业务无关的，没有紧密性的。比如记录日志信息等业务。这个时候正常就是启一个新线程去做一些业务处理，让主线程异步的执行其他业务。

这里说一下springboot下的异步调用：

需要在启动类加入@EnableAsync使异步调用@Async注解生效

@EnableAsync   //异步线程执行启用
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

在需要异步执行的方法上加入此注解即可@Async(“threadPool”),threadPool为自定义线程池
在默认情况下，未设置TaskExecutor时，默认是使用SimpleAsyncTaskExecutor这个线程池，但此线程不是真正意义上的线程池，因为线程不重用，每次调用都会创建一个新的线程。可通过控制台日志输出可以看出，每次输出线程名都是递增的。所以最好我们来自定义一个线程池。
那如何自定义一个线程池呢。下面会有讲述。
4.1. 首先自定义配置类

@Configuration
@EnableAsync
@ConfigurationProperties(prefix = "spring.task.pool")
public class ExecutorConfig {
	/**
	 * 线程池维护的核心数量
	 */
	private int corePoolSize ;
	/**
	 * 线程池维护线程的最大数量
	 */
	private int maxPoolSize ;
	/**
	 * 线程池所使用的缓冲队列
	 */
	private int queueCapacity;
	/**
	 * 线程池维护线程所允许的空闲时间
	 */
	private int keepAliveSeconds;

	/**
	 * 此bean用于埋点线程池。由于埋点数据的可丢失性。使用DiscardPolicy任务拒绝策略。
	 * @return
	 */
	@Bean
	public Executor KITSimpleAsync() {
		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
		executor.setCorePoolSize(corePoolSize);
		executor.setMaxPoolSize(maxPoolSize);
		executor.setQueueCapacity(queueCapacity);
		executor.setKeepAliveSeconds(keepAliveSeconds);
		//任务拒绝策略。用于被拒绝任务的处理程序，DiscardPolicy 默认情况下它将丢弃被拒绝的任务。
		executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
		executor.setThreadNamePrefix("KITSimpleAsync---");
		executor.initialize();
		return executor;
	}


	public int getCorePoolSize() {
		return corePoolSize;
	}


	public int getKeepAliveSeconds() {
		return keepAliveSeconds;
	}

	public void setKeepAliveSeconds(int keepAliveSeconds) {
		this.keepAliveSeconds = keepAliveSeconds;
	}

	public void setCorePoolSize(int corePoolSize) {
		this.corePoolSize = corePoolSize;
	}

	public int getMaxPoolSize() {
		return maxPoolSize;
	}

	public void setMaxPoolSize(int maxPoolSize) {
		this.maxPoolSize = maxPoolSize;
	}

	public int getQueueCapacity() {
		return queueCapacity;
	}

	public void setQueueCapacity(int queueCapacity) {
		this.queueCapacity = queueCapacity;
	}
}

4.2. 配置文件对应配置如下：

spring:
  task:
    pool:
      corePoolSize: 5
      maxPoolSize: 300
      queueCapacity: 100
      keepAliveSeconds: 30000

4.3. 使用时直接标注注解就可以使用

    // 发送消息，destination是发送到的队列，message是待发送的消息
    @Async("KITSimpleAsync")异步发送。使用自定义线程池  详见ExecutorConfig
    public void sendMessage(Destination destination,final String message){
        jmsTemplate.convertAndSend(destination,message);
    }

调用的异步方法，不能为同一个类的方法（包括同一个类的内部类），简单来说，因为Spring在启动扫描时会为其创建一个代理类，而同类调用时，还是调用本身的代理类的，所以和平常调用是一样的。
其他的注解如@Cache等也是一样的道理，说白了，就是Spring的代理机制造成的。所以在开发中，最好把异步服务单独抽出一个类来管理。下面会重点讲述。
什么情况下会导致@Async异步方法会失效？
a. 调用同一个类下注有@Async异步方法：在spring中像@Async和@Transactional、cache等注解本质使用的是动态代理，其实Spring容器在初始化的时候Spring容器会将含有AOP注解的类对象“替换”为代理对象（简单这么理解），那么注解失效的原因就很明显了，就是因为调用方法的是对象本身而不是代理对象，因为没有经过Spring容器，那么解决方法也会沿着这个思路来解决。
b. 调用的是静态(static )方法
c. 调用(private)私有化方法
解决同一个类中调用异步方法不起作用的问题
将要异步执行的方法单独抽取成一个类，原理就是当你把执行异步的方法单独抽取成一个类的时候，这个类肯定是被Spring管理的，其他Spring组件需要调用的时候肯定会注入进去，这时候实际上注入进去的就是代理类了。
其实我们的注入对象都是从Spring容器中给当前Spring组件进行成员变量的赋值，由于某些类使用了AOP注解，那么实际上在Spring容器中实际存在的是它的代理对象。那么我们就可以通过上下文获取自己的代理对象调用异步方法。
7.1

@Controller
@RequestMapping("/app")
public class EmailController {

    //获取ApplicationContext对象方式有多种,这种最简单,其它的大家自行了解一下
    @Autowired
    private ApplicationContext applicationContext;

    @RequestMapping(value = "/email/asyncCall", method = GET)
    @ResponseBody
    public Map<String, Object> asyncCall () {
        Map<String, Object> resMap = new HashMap<String, Object>();
        try{
            //这样调用同类下的异步方法是不起作用的
            //this.testAsyncTask();
            //通过上下文获取自己的代理对象调用异步方法
            EmailController emailController = (EmailController)applicationContext.getBean(EmailController.class);
            emailController.testAsyncTask();
            resMap.put("code",200);
        }catch (Exception e) {
            resMap.put("code",400);
            logger.error("error!",e);
        }
        return resMap;
    }

    //注意一定是public,且是非static方法
    @Async
    public void testAsyncTask() throws InterruptedException {
        Thread.sleep(10000);
        System.out.println("异步任务执行完成！");
    }

}

7.2 另一种方式：开启cglib代理，手动获取Spring代理类,从而调用同类下的异步方法。
首先，在启动类上加上@EnableAspectJAutoProxy(exposeProxy = true)注解。

@EnableAspectJAutoProxy(exposeProxy = true)  //开启cglib代理。使得能够调用同类中的异步方法
public class Application {


    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

代码使用如下：

@Service
@Transactional(value = "transactionManager", readOnly = false, propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
public class EmailService {

    @Autowired
    private ApplicationContext applicationContext;

    @Async
    public void testSyncTask() throws InterruptedException {
        Thread.sleep(10000);
        System.out.println("异步任务执行完成！");
    }


    public void asyncCallTwo() throws InterruptedException {
        boolean isAop = AopUtils.isAopProxy(EmailController.class);//是否是代理对象；
        boolean isCglib = AopUtils.isCglibProxy(EmailController.class);  //是否是CGLIB方式的代理对象；
        boolean isJdk = AopUtils.isJdkDynamicProxy(EmailController.class);  //是否是JDK动态代理方式的代理对象；
        //以下才是重点!!!
        EmailService emailService = (EmailService)applicationContext.getBean(EmailService.class);
        EmailService proxy = (EmailService) AopContext.currentProxy();
        System.out.println(emailService == proxy ? true : false);
        proxy.testSyncTask();
        System.out.println("end!!!");
    }
}

线程池的说明较少网上资料也比较多，这举几个例子
https://blog.youkuaiyun.com/foreverling/article/details/78073105