定时任务下的多线程任务

1、Spring的ServletContextListener

ServletContext > webApplicationContext ServletContext 是java中的Servlet工程的上下文对象 webApplicationContext是Spring框架中定义的继承了ServletContext上下文对象的web上下文对象

Spring框架定义了一个ContextLoaderListener继承了ServletContextListener,在监听整个Spring的IOC容器(通过DI将创建对象的工作交给Spring框架)的创建与销毁。

2、在ServletContextListener中监听上下文初始化的事件

1. public void contextInitialized(ServletContextEvent arg0) {}

在Servlet容器初始化完成后，开启一个定时任务。

3、使用Java中的定时器Timer(true:后台线程跑)

1. Timer timer = new Timer(true);
2. timer.schedule(new AlarmTask(),5*1000,10*1000);

4、自定义TimerTask类

1. public class AlarmTask extends TimerTask {
2. @Override
3. public void run() {}
4. }

TimerTask源码：实现了多线程

1. package java.util;
3. public abstract class TimerTask implements Runnable {
4. protected TimerTask() {
5. throw new RuntimeException("Stub!");
6. }
8. public boolean cancel() {
9. throw new RuntimeException("Stub!");
10. }
12. public long scheduledExecutionTime() {
13. throw new RuntimeException("Stub!");
14. }
16. public abstract void run();
17. }

5、在自定义Task类里面使用AtomicBoolean实现定时任务的原子性

1. boolean compareAndSet(expectedValue, updateValue);

我们看到了上面提到的一个在java并发中非常重要的一类算法 -- CAS: Compare And Set 比较并设置； 什么意思呢，我们以   boolean compareAndSet(expectedValue, updateValue);方法为例来解释CAS的思想， 内存中可见的值如果和期望值(expectedValue)一致， 则将内存中的值修改为新值(updateValue)，并且返回true； 否则返回false；

该操作是原子性的，意思是线程安全的。当多个线程同时访问某个对象时，如果其中一个线程通过CAS操作获得了访问权限，则其他线程只能在该线程处理完之后才能访问。这类似于同步字   synchronized  但是效率更高因为并没有锁的机制

demo代码：

1. /**
2. *
3. */
4. package byron4j.dlzd.curr.atomic;
6. import java.time.LocalDate;
7. import java.time.LocalTime;
8. import java.util.concurrent.ExecutorService;
9. import java.util.concurrent.Executors;
10. import java.util.concurrent.TimeUnit;
11. import java.util.concurrent.atomic.AtomicBoolean;
14. public class AtomicDemo {
16. private static volatile AtomicBoolean canExecutingFlag = new AtomicBoolean(true);
20. /**
21. *
22. * 业务逻辑处理:
23. *
    1. *
    2. Step 1
    3. *
    4. Step 2
    5. *
24. */
25. public void executeBusiLogic(){
26. if( canExecutingFlag.compareAndSet(true, false) ){
27. try{
28. System.out.println(LocalDate.now() + " " + LocalTime.now() + "--" + Thread.currentThread().getName() + "--处理业务逻辑开始...");
29. Thread.sleep(5000);
30. System.out.println(LocalDate.now() + " " + LocalTime.now() + "--" + Thread.currentThread().getName() + "--处理业务逻辑完毕.");
31. }catch(Exception e){
32. System.out.println(LocalDate.now() + " " + LocalTime.now() + "--" + Thread.currentThread().getName() + "--处理业务逻辑失败!!!");
33. }finally{
34. canExecutingFlag.set(true);
35. }
36. }else{
37. System.out.println(LocalDate.now() + " " + LocalTime.now() + "--" + Thread.currentThread().getName() + "--已经存在处理中的业务，请稍后再试!");
38. }
39. }
43. public static void main(String[] args) {
44. ExecutorService es = Executors.newFixedThreadPool(10);
46. AtomicDemo demo = new AtomicDemo();
48. for(int i = 0; i < 10; i++){
49. es.execute(new Runnable() {
51. @Override
52. public void run() {
53. demo.executeBusiLogic();
54. }
55. });
56. }
58. es.shutdown();
59. }
60. }

运行结果如下：

1. 2017-09-13 22:13:45.081--pool-1-thread-3--已经存在处理中的业务，请稍后再试!
2. 2017-09-13 22:13:45.082--pool-1-thread-2--已经存在处理中的业务，请稍后再试!
3. 2017-09-13 22:13:45.082--pool-1-thread-6--已经存在处理中的业务，请稍后再试!
4. 2017-09-13 22:13:45.081--pool-1-thread-1--处理业务逻辑开始...
5. 2017-09-13 22:13:45.081--pool-1-thread-10--已经存在处理中的业务，请稍后再试!
6. 2017-09-13 22:13:45.081--pool-1-thread-9--已经存在处理中的业务，请稍后再试!
7. 2017-09-13 22:13:45.082--pool-1-thread-4--已经存在处理中的业务，请稍后再试!
8. 2017-09-13 22:13:45.081--pool-1-thread-7--已经存在处理中的业务，请稍后再试!
9. 2017-09-13 22:13:45.082--pool-1-thread-5--已经存在处理中的业务，请稍后再试!
10. 2017-09-13 22:13:45.083--pool-1-thread-8--已经存在处理中的业务，请稍后再试!
11. 2017-09-13 22:13:50.082--pool-1-thread-1--处理业务逻辑完毕.

我们看到thread-1首先获得操作权限canExecutingFlag 值为true，CAS验证通过并且将canExecutingFlag 值置为false，所以其他线程均未获得进入资格，因为处理业务逻辑花了5秒钟，其他线程得到了"已经在处理中"的提示。 为了模拟耗时操作，我们在 executeBusiLogic 方法中通过sleep使执行线程睡眠。

6、通过Queue实现多线程队列执行并结合CountDownLatch计数器实现

业务场景：在定时任务中我们需要创建对个线程，同时进行上报告警的操作，但是又需要保证 当前的多线程报警操作在当前定时任务主线程内。也就是说： 多线程的报警需要在一次定时任务内执行完毕后，再执行下一次定时任务。

6.1 创建多线程队列：

1. ConcurrentLinkedQueue<Runnable> tasksQueue = new ConcurrentLinkedQueue<>();

6.2 创建计数器（构造方法中声明计数器大小）

1. CountDownLatch cdl = new CountDownLatch(tasksQueue.size());

6.3 获取线程并实现计数

1. public static void main(String args[]) {
2. while(true) {
3. Runnable task = tasksQueue.poll();//弹出队列中第一个
4. while(task == null) {
5. break;
6. }
7. new Thread(task).start();
8. cdl.countDown();
9. }
10. cdl.await();
11. }

主线程必须在启动其他线程后立即调用 await() 方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。

---

第五部分摘抄自：

作者：东陆之滇
链接：https://www.jianshu.com/p/eabecdbc6bd9

关于CountDownLatch的更多详细了解：https://www.cnblogs.com/catkins/p/6021992.html