public class AsyncThread extends Thread {
    @Override
    public void run(){
        System.out.println("Current thread name:" + Thread.currentThread().getName()+"send 
        email success!");
    }
 
    public static void main(String[] args){
        AsyncThread asyncThread=new AsyncThread();
        asyncThread.run();
    }
}

private ExecutorService executorService = Executors.newCachedThreadPool();
 
public void fun(){
    excutorService.submit(new Runnanle(){
        @Override
        public void run() {
            log.info("執(zhí)行業(yè)務(wù)邏輯...");
        }
    });
}

@Slf4j
public class FutureManager {
        public String execute() throws Exception {
                ExecutorService executor = Executors.newFixedThreadPool(1);
                Future<String> future = executor.submit(new Callable<String>(){
                    @Override
                    public String call() throws Exception {
                        System.out.println("--- task start ---");
                        Thread.sleep(3000);
                        System.out.println("--- task finish ---");
                    }
                });
                //這里需要返回值時(shí)會(huì)阻塞主線程
                String result=future.get();
                log.inf("Future get result:{}",result);
                return result;
        }
        
        @SneakyThrows
        public static void main(String[] args){
            FutureManager manager=new FutureManager();
            manager.execute();
        }
}

--- task start --- 
 --- task finish ---
 Future get result: this is future execute final result!!!

public class CompletableFutureCompose{
    /**
    *thenAccept子任務(wù)和父任務(wù)公用同一個(gè)線程
    */
    @SneakyThrows
    public static void thenRunAsync(){
        CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+"cf1 do something....");
            return 1;
        });
 
        CompletalbeFuture<Void> cf2 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+"cf2 do something....");
        });
        //等待任務(wù)1執(zhí)行完成
        System.out.println("cf1結(jié)果->"+cf1.get());
        //等待任務(wù)2執(zhí)行完成
        System.out.println("cf2結(jié)果->"+cf2.get());
    }
 
    public static void main(String[] args){
        thenRunAsync();
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
import java.util.concurrent.Executor;
 
/**
 * 線程池參數(shù)配置，多個(gè)線程池實(shí)現(xiàn)線程池隔離，@Async注解，默認(rèn)使用系統(tǒng)自定義線程池，可在項(xiàng)目中設(shè)置多個(gè)線程池，在異步調(diào)用的時(shí)候，指明需要調(diào)用的線程池名稱，比如：@Async("taskName")
 */
@EnableAsync
@Configuration
public class TaskPoolConfig {
    /**
     * 自定義線程池
     */
    @Bean("taskExecutor")
    public Executor taskExecutor() {
        // 返回可用處理器的Java虛擬機(jī)的數(shù)量 12
        int i = Runtime.getRuntime().availableProcessors();
        System.out.println("系統(tǒng)最大線程數(shù)  ：" + i);
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心線程池大小
        executor.setCorePoolSize(16);
        // 最大線程數(shù)
        executor.setMaxPoolSize(20);
        // 配置隊(duì)列容量，默認(rèn)值為Integer.MAX_VALUE
        executor.setQueueCapacity(99999);
        // 活躍時(shí)間
        executor.setKeepAliveSeconds(60);
        // 線程名字前綴
        executor.setThreadNamePrefix("asyncServiceExecutor -");
        // 設(shè)置此執(zhí)行程序應(yīng)該在關(guān)閉時(shí)阻止的最大秒數(shù)，以便在容器的其余部分繼續(xù)關(guān)閉之前等待剩余的任務(wù)完成他們的執(zhí)行
        executor.setAwaitTerminationSeconds(60);
        // 等待所有的任務(wù)結(jié)束后再關(guān)閉線程池
        executor.setWaitForTasksToCompleteOnShutdown(true);
        return executor;
    }
}

public interface AsyncService {
    MessageResult sendSms(String callPrefix, String mobile, String actionType, String content);
    MessageResult sendEmail(String email, String subject, String content);
}
 
@Slf4j
@Service
public class AsyncServiceImpl implements AsyncService {
    @Autowired
    private IMessageHandler mesageHandler;
 
    @Override
    @Async("taskExecutor")
    public MessageResult sendSms(String callPrefix, String mobile, String actionType, String content) {
        try {
            Thread.sleep(1000);
            mesageHandler.sendSms(callPrefix, mobile, actionType, content);
 
        } catch (Exception e) {
            log.error("發(fā)送短信異常 -> ", e)
        }
    }
 
    @Override
    @Async("taskExecutor")
    public sendEmail(String email, String subject, String content) {
        try {
            Thread.sleep(1000);
            mesageHandler.sendsendEmail(email, subject, content);
        } catch (Exception e) {
            log.error("發(fā)送email異常 -> ", e)
        }
    }
}

 
public class AsyncSendEmailEvent extends ApplicationEvent {
    /**
     * 郵箱
     **/
    private String email;
   /**
     * 主題
     **/
    private String subject;
    /**
     * 內(nèi)容
     **/
    private String content;
 
    /**
     * 接收者
     **/
    private String targetUserId;
}

@Slf4j
@Component
public class AsyncSendEmailEventHandler implements ApplicationListener<AsyncSendEmailEvent> {
 
    @Autowired
    private IMessageHandler mesageHandler;
 
    @Async("taskExecutor")
    @Override
    public void onApplicationEvent(AsyncSendEmailEvent event) {
        if (event == null) {
            return;
        }
 
        String email = event.getEmail();
        String subject = event.getSubject();
        String content = event.getContent();
        String targetUserId = event.getTargetUserId();
        mesageHandler.sendsendEmailSms(email, subject, content, targerUserId);
      }
}

 
@Slf4j
@Component
public class CallbackProducer {
    @Autowired
    AmqpTemplate amqpTemplate;
 
    public void sendCallbackMessage(CallbackDTO allbackDTO, final long delayTimes) {
 
        log.info("生產(chǎn)者發(fā)送消息，callbackDTO，{}", callbackDTO);
 
        amqpTemplate.convertAndSend(CallbackQueueEnum.QUEUE_GENSEE_CALLBACK.getExchange(), CallbackQueueEnum.QUEUE_GENSEE_CALLBACK.getRoutingKey(), JsonMapper.getInstance().toJson(genseeCallbackDTO), new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //給消息設(shè)置延遲毫秒值，通過給消息設(shè)置x-delay頭來設(shè)置消息從交換機(jī)發(fā)送到隊(duì)列的延遲時(shí)間
                message.getMessageProperties().setHeader("x-delay", delayTimes);
                message.getMessageProperties().setCorrelationId(callbackDTO.getSdkId());
                return message;
            }
        });
    }
}

 
@Slf4j
@Component
@RabbitListener(queues = "message.callback",containerFactory="rabbitListenerContainerFactory")
public class CallbackConsumer {
    @Autowired
    private IGlobalUserService globalUserService;
    
    @RabbitHandler
    public void handle(String json,Channel channel,@Headers Map<String,Object> map) throws Exception {
        if(map.get("error")!=null){
            //否認(rèn)消息
            channel.basicNack((Long)map.get(AmqpHeaders.DELIVERY_TAG),false,true);
            return;
        }
        try{
            CallbackDTO callbackDTO=JsonMapper.getInstance().fromJson(json,CallbackDTO.class);
            //執(zhí)行業(yè)務(wù)邏輯
            globalUserService.execute(callbackDTO);
            //消息成功手動(dòng)確認(rèn)，對(duì)應(yīng)消息確認(rèn)模式acknowledge-mode:manual
            channel.basicAck((Long)map.get(AmqpHeaders.DELIVERY_TAG),false)
        }catch(Exception e){
            log.error("回調(diào)失敗->{}",e);
        }
    }
}

@Slf4j
public class ThreadUtils{
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            ThreadUtil.execAsync(()->{
                ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
                int num= threadLocalRandom.next(20)+1;
                System.out.println(num);
            });
            log.info("當(dāng)前第"+i+"個(gè)線程");
        }
        log.info("task finish!");
    }
}

ListeningExecutorService executorService = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
  final ListenableFuture<Integer> listenableFuture = executorService.submit(new Callable<Integer>() {
    @Override
    public Integer call() throws Exception {
      log.info("callable execute...")
      TimeUnit.SECONDS.sleep(1);
      return 1;
    }
  }
);

Futures.addCallback(listenableFuture, new FutureCallback<Integer>() {
    @Override
    public void onSuccess(Integer result) {
        //成功執(zhí)行...
        System.out.println("Get listenable future's result with callback " + result);
    }
 
    @Override
    public void onFailure(Throwable t) {
        //異常情況處理...
        t.printStackTrace();
    }
});